adding assertion to prevent recursive compound types

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 01c50ed..1c42a91 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -12,8 +12,11 @@
 
 /**
  *
- *   file type.c - implementation of the datastructure to hold
- *   type information.
+ *  @file type.c
+ *
+ *  Implementation of the datastructure to hold
+ *  type information.
+ *
  *  (C) 2001 by Universitaet Karlsruhe
  *  Goetz Lindenmaier
  *
@@ -64,16 +67,16 @@
 
 # include "array.h"
 
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
 /** TYPE                                                          **/
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
 
 type *firm_none_type;    type *get_none_type(void)    { return firm_none_type;    }
 type *firm_unknown_type; type *get_unknown_type(void) { return firm_unknown_type; }
 
 
 #ifdef DEBUG_libfirm
-/** Returns a new, unique number to number nodes or the like. */
+/* Returns a new, unique number to number nodes or the like. */
 int get_irp_new_node_nr(void);
 #endif
 
@@ -116,17 +119,18 @@ new_type(tp_op *type_op, ir_mode *mode, ident* name) {
   memset(res, 0, node_size);
   add_irp_type(res);   /* Remember the new type global. */
 
-  res->kind    = k_type;
-  res->type_op = type_op;
-  res->mode    = mode;
-  res->name    = name;
-  res->state   = layout_undefined;
-  res->size    = -1;
-  res->align   = -1;
-  res->visit   = 0;
-  res -> link  = NULL;
+  res->kind       = k_type;
+  res->type_op    = type_op;
+  res->mode       = mode;
+  res->name       = name;
+  res->visibility = visibility_external_allocated;
+  res->state      = layout_undefined;
+  res->size       = -1;
+  res->align      = -1;
+  res->visit      = 0;
+  res -> link     = NULL;
 #ifdef DEBUG_libfirm
-  res->nr      = get_irp_new_node_nr();
+  res->nr         = get_irp_new_node_nr();
 #endif /* defined DEBUG_libfirm */
 
   return res;
@@ -274,6 +278,57 @@ int (get_type_size_bits)(const type *tp) {
   return _get_type_size_bits(tp);
 }
 
+
+visibility get_type_visibility (const type *tp) {
+#if 0
+  visibility res =  visibility_local;
+  if (is_compound_type(tp)) {
+
+    if (is_Array_type(tp)) {
+      entity *mem = get_array_element_entity(tp);
+      if (get_entity_visibility(mem) != visibility_local)
+       res = visibility_external_visible;
+    } else {
+      int i, n_mems = get_compound_n_members(tp);
+      for (i = 0; i < n_mems; ++i) {
+       entity *mem = get_compound_member(tp, i);
+       if (get_entity_visibility(mem) != visibility_local)
+         res = visibility_external_visible;
+      }
+    }
+  }
+  return res;
+#endif
+  assert(is_type(tp));
+  return tp->visibility;
+}
+
+void       set_type_visibility (type *tp, visibility v) {
+  assert(is_type(tp));
+#if 0
+  /* check for correctness */
+  if (v != visibility_external_allocated) {
+    visibility res =  visibility_local;
+    if (is_compound_type(tp)) {
+      if (is_Array_type(tp)) {
+       entity *mem = get_array_element_entity(tp);
+       if (get_entity_visibility(mem) >  res)
+         res = get_entity_visibility(mem);
+      } else {
+       int i, n_mems = get_compound_n_members(tp);
+       for (i = 0; i < n_mems; ++i) {
+         entity *mem = get_compound_member(tp, i);
+         if (get_entity_visibility(mem) > res)
+           res = get_entity_visibility(mem);
+       }
+      }
+    }
+    assert(res < v);
+  }
+#endif
+  tp->visibility = v;
+}
+
 void
 set_type_size_bits(type *tp, int size) {
   assert(tp && tp->kind == k_type);
@@ -748,6 +803,7 @@ void free_class_attrs(type *clss) {
 /* manipulate private fields of class type  */
 void    add_class_member   (type *clss, entity *member) {
   assert(clss && (clss->type_op == type_class));
+  assert(clss != get_entity_type(member) && "recursive type");
   ARR_APP1 (entity *, clss->attr.ca.members, member);
 }
 
@@ -970,6 +1026,7 @@ void    add_struct_member   (type *strct, entity *member) {
   assert(strct && (strct->type_op == type_struct));
   assert(get_type_tpop(get_entity_type(member)) != type_method);
     /*    @@@ lowerfirm geht nicht durch */
+  assert(strct != get_entity_type(member) && "recursive type");
   ARR_APP1 (entity *, strct->attr.sa.members, member);
 }
 
@@ -1310,6 +1367,7 @@ int    get_union_n_members      (const type *uni) {
 }
 void    add_union_member   (type *uni, entity *member) {
   assert(uni && (uni->type_op == type_union));
+  assert(uni != get_entity_type(member) && "recursive type");
   ARR_APP1 (entity *, uni->attr.ua.members, member);
 }
 entity  *get_union_member (const type *uni, int pos) {