X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=a60b96cb499938b94203609aee84facba5911f0e;hb=d0d85962ef52c14950db90e5981a7bea36023ab3;hp=5ceb3934afe13f69c4e1a15aff9af9b8615827b0;hpb=159df4564ce78bfdb54d7e756b914549801e210f;p=libfirm

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 5ceb3934a..a60b96cb4 100644
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -6,7 +6,7 @@
  * Modified by: Michael Beck
  * Created:
  * CVS-ID:      $Id$
- * Copyright:   (c) 2001-2003 Universität Karlsruhe
+ * Copyright:   (c) 2001-2006 Universität Karlsruhe
  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  */
 
@@ -55,20 +55,22 @@
 # include <stdlib.h>
 #endif
 
-# include <stddef.h>
+#include <stddef.h>
 
-# include "type_t.h"
+#include "type_t.h"
 
-# include "xmalloc.h"
-# include "irprog_t.h"
-# include "ircons.h"
-# include "tpop_t.h"
-# include "typegmod.h"
-# include "mangle.h"
-# include "tv_t.h"
-# include "irhooks.h"
+#include "xmalloc.h"
+#include "irprog_t.h"
+#include "ircons.h"
+#include "tpop_t.h"
+#include "typegmod.h"
+#include "mangle.h"
+#include "tv_t.h"
+#include "irhooks.h"
+#include "irtools.h"
+#include "entity_t.h"
 
-# include "array.h"
+#include "array.h"
 
 /*-----------------------------------------------------------------*/
 /** TYPE                                                          **/
@@ -78,11 +80,6 @@ ir_type *firm_none_type;    ir_type *get_none_type(void)    { return firm_none_t
 ir_type *firm_unknown_type; ir_type *get_unknown_type(void) { return firm_unknown_type; }
 
 
-#ifdef DEBUG_libfirm
-/* Returns a new, unique number to number nodes or the like. */
-int get_irp_new_node_nr(void);
-#endif
-
 /* Suffixes added to types used for pass-by-value representations. */
 static ident *value_params_suffix = NULL;
 static ident *value_ress_suffix = NULL;
@@ -241,7 +238,7 @@ long get_type_nr(const ir_type *tp) {
 #ifdef DEBUG_libfirm
   return tp->nr;
 #else
-  return (long)tp;
+  return (long)PTR_TO_INT(tp);
 #endif
 }
 
@@ -259,19 +256,19 @@ int (get_type_size_bits)(const ir_type *tp) {
 }
 
 
-visibility get_type_visibility (const ir_type *tp) {
+ir_visibility get_type_visibility (const ir_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);
+      ir_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);
+        ir_entity *mem = get_compound_member(tp, i);
         if (get_entity_visibility(mem) != visibility_local)
           res = visibility_external_visible;
       }
@@ -283,7 +280,7 @@ visibility get_type_visibility (const ir_type *tp) {
   return tp->visibility;
 }
 
-void       set_type_visibility (ir_type *tp, visibility v) {
+void       set_type_visibility (ir_type *tp, ir_visibility v) {
   assert(is_type(tp));
 #if 0
   /* check for correctness */
@@ -291,13 +288,13 @@ void       set_type_visibility (ir_type *tp, visibility v) {
     visibility res =  visibility_local;
     if (is_compound_type(tp)) {
       if (is_Array_type(tp)) {
-        entity *mem = get_array_element_entity(tp);
+        ir_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);
+	        ir_entity *mem = get_compound_member(tp, i);
 	        if (get_entity_visibility(mem) > res)
 	          res = get_entity_visibility(mem);
         }
@@ -365,6 +362,7 @@ int get_type_alignment_bits(ir_type *tp) {
 void
 set_type_alignment_bits(ir_type *tp, int align) {
   assert(tp && tp->kind == k_type);
+  assert((align == -1 || (align & (align - 1)) == 0) && "type alignment not power of two");
   /* Methods don't have an alignment. */
   if (tp->type_op != type_method) {
     tp->align = align;
@@ -373,7 +371,11 @@ set_type_alignment_bits(ir_type *tp, int align) {
 
 void
 set_type_alignment_bytes(ir_type *tp, int align) {
-  set_type_alignment_bits(tp, 8*align);
+	if (align == -1) {
+		set_type_alignment_bits(tp, -1);
+	} else {
+		set_type_alignment_bits(tp, 8*align);
+	}
 }
 
 /* Returns a human readable string for the enum entry. */
@@ -405,50 +407,48 @@ set_type_state(ir_type *tp, type_state state) {
     int i;
     switch (get_type_tpop_code(tp)) {
     case tpo_class:
-      {
-    assert(get_type_size_bits(tp) > -1);
-    if (tp != get_glob_type()) {
-      int n_mem = get_class_n_members(tp);
-      for (i = 0; i < n_mem; i++) {
-        if (get_entity_offset_bits(get_class_member(tp, i)) <= -1)
-          { DDMT(tp); DDME(get_class_member(tp, i)); }
-        assert(get_entity_offset_bits(get_class_member(tp, i)) > -1);
-            /* TR ??
-        assert(is_Method_type(get_entity_type(get_class_member(tp, i))) ||
-           (get_entity_allocation(get_class_member(tp, i)) == allocation_automatic));
-                   */
+      assert(get_type_size_bits(tp) > -1);
+      if (tp != get_glob_type()) {
+        int n_mem = get_class_n_members(tp);
+        for (i = 0; i < n_mem; i++) {
+          assert(get_entity_offset(get_class_member(tp, i)) > -1);
+              /* TR ??
+          assert(is_Method_type(get_entity_type(get_class_member(tp, i))) ||
+             (get_entity_allocation(get_class_member(tp, i)) == allocation_automatic));
+                     */
+        }
       }
-    }
-      } break;
+      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));
-        }
-      } break;
+      assert(get_type_size_bits(tp) > -1);
+      for (i = 0; i < get_struct_n_members(tp); i++) {
+        assert(get_entity_offset(get_struct_member(tp, i)) > -1);
+        assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
+      }
+      break;
     case tpo_union:
-      { /* ?? */
-      } break;
+      /* ?? */
+      break;
     case tpo_array:
-      { /* ??
+      /* ??
          Check order?
          Assure that only innermost dimension is dynamic? */
-      } break;
+      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);
-      } break;
+      assert(get_type_mode != NULL);
+      for (i = get_enumeration_n_enums(tp) - 1; i >= 0; --i) {
+        ir_enum_const *ec = get_enumeration_const(tp, i);
+        tarval        *tv = get_enumeration_value(ec);
+        assert(tv != NULL && tv != tarval_bad);
+      }
+      break;
     default: break;
     } /* switch (tp) */
   }
-  if (state = layout_fixed)
+  if (state == layout_fixed)
     tp->flags |= tf_layout_fixed;
   else
-    tp->flags &= tf_layout_fixed;
+    tp->flags &= ~tf_layout_fixed;
 }
 
 unsigned long (get_type_visited)(const ir_type *tp) {
@@ -478,7 +478,7 @@ int (is_type)(const void *thing) {
 
 /* Checks whether two types are structural equal.*/
 int equal_type(ir_type *typ1, ir_type *typ2) {
-  entity **m;
+  ir_entity **m;
   ir_type **t;
   int i, j;
 
@@ -500,13 +500,13 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
     if (get_class_n_supertypes(typ1) != get_class_n_supertypes(typ2)) return 0;
     if (get_class_peculiarity(typ1) != get_class_peculiarity(typ2)) return 0;
     /** Compare the members **/
-    m = alloca(sizeof(entity *) * get_class_n_members(typ1));
-    memset(m, 0, sizeof(entity *) * get_class_n_members(typ1));
+    m = alloca(sizeof(ir_entity *) * get_class_n_members(typ1));
+    memset(m, 0, sizeof(ir_entity *) * get_class_n_members(typ1));
     /* First sort the members of typ2 */
     for (i = 0; i < get_class_n_members(typ1); i++) {
-      entity *e1 = get_class_member(typ1, i);
+      ir_entity *e1 = get_class_member(typ1, i);
       for (j = 0; j < get_class_n_members(typ2); j++) {
-        entity *e2 = get_class_member(typ2, j);
+        ir_entity *e2 = get_class_member(typ2, j);
         if (get_entity_name(e1) == get_entity_name(e2))
           m[i] = e2;
       }
@@ -517,8 +517,8 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
         return 0;
     }
     /** Compare the supertypes **/
-    t = alloca(sizeof(entity *) * get_class_n_supertypes(typ1));
-    memset(t, 0, sizeof(entity *) * get_class_n_supertypes(typ1));
+    t = alloca(sizeof(ir_entity *) * get_class_n_supertypes(typ1));
+    memset(t, 0, sizeof(ir_entity *) * get_class_n_supertypes(typ1));
     /* First sort the supertypes of typ2 */
     for (i = 0; i < get_class_n_supertypes(typ1); i++) {
       ir_type *t1 = get_class_supertype(typ1, i);
@@ -536,13 +536,13 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
   } break;
   case tpo_struct:      {
     if (get_struct_n_members(typ1) != get_struct_n_members(typ2)) return 0;
-    m = alloca(sizeof(entity *) * get_struct_n_members(typ1));
-    memset(m, 0, sizeof(entity *) * get_struct_n_members(typ1));
+    m = alloca(sizeof(ir_entity *) * get_struct_n_members(typ1));
+    memset(m, 0, sizeof(ir_entity *) * get_struct_n_members(typ1));
     /* First sort the members of lt */
     for (i = 0; i < get_struct_n_members(typ1); i++) {
-      entity *e1 = get_struct_member(typ1, i);
+      ir_entity *e1 = get_struct_member(typ1, i);
       for (j = 0; j < get_struct_n_members(typ2); j++) {
-        entity *e2 = get_struct_member(typ2, j);
+        ir_entity *e2 = get_struct_member(typ2, j);
         if (get_entity_name(e1) == get_entity_name(e2))
           m[i] = e2;
       }
@@ -583,13 +583,13 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
   } break;
   case tpo_union:       {
     if (get_union_n_members(typ1) != get_union_n_members(typ2)) return 0;
-    m = alloca(sizeof(entity *) * get_union_n_members(typ1));
-    memset(m, 0, sizeof(entity *) * get_union_n_members(typ1));
+    m = alloca(sizeof(ir_entity *) * get_union_n_members(typ1));
+    memset(m, 0, sizeof(ir_entity *) * get_union_n_members(typ1));
     /* First sort the members of lt */
     for (i = 0; i < get_union_n_members(typ1); i++) {
-      entity *e1 = get_union_member(typ1, i);
+      ir_entity *e1 = get_union_member(typ1, i);
       for (j = 0; j < get_union_n_members(typ2); j++) {
-        entity *e2 = get_union_member(typ2, j);
+        ir_entity *e2 = get_union_member(typ2, j);
         if (get_entity_name(e1) == get_entity_name(e2))
           m[i] = e2;
       }
@@ -629,7 +629,7 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
 
 /* Checks whether two types are structural comparable. */
 int smaller_type (ir_type *st, ir_type *lt) {
-  entity **m;
+  ir_entity **m;
   int i, j;
 
   if (st == lt) return 1;
@@ -643,13 +643,13 @@ int smaller_type (ir_type *st, ir_type *lt) {
   } break;
   case tpo_struct:      {
     if (get_struct_n_members(st) != get_struct_n_members(lt)) return 0;
-    m = alloca(sizeof(entity *) * get_struct_n_members(st));
-    memset(m, 0, sizeof(entity *) * get_struct_n_members(st));
+    m = alloca(sizeof(ir_entity *) * get_struct_n_members(st));
+    memset(m, 0, sizeof(ir_entity *) * get_struct_n_members(st));
     /* First sort the members of lt */
     for (i = 0; i < get_struct_n_members(st); i++) {
-      entity *se = get_struct_member(st, i);
+      ir_entity *se = get_struct_member(st, i);
       for (j = 0; j < get_struct_n_members(lt); j++) {
-        entity *le = get_struct_member(lt, j);
+        ir_entity *le = get_struct_member(lt, j);
         if (get_entity_name(le) == get_entity_name(se))
           m[i] = le;
       }
@@ -692,13 +692,13 @@ int smaller_type (ir_type *st, ir_type *lt) {
   } break;
   case tpo_union:       {
     if (get_union_n_members(st) != get_union_n_members(lt)) return 0;
-    m = alloca(sizeof(entity *) * get_union_n_members(st));
-    memset(m, 0, sizeof(entity *) * get_union_n_members(st));
+    m = alloca(sizeof(ir_entity *) * get_union_n_members(st));
+    memset(m, 0, sizeof(ir_entity *) * get_union_n_members(st));
     /* First sort the members of lt */
     for (i = 0; i < get_union_n_members(st); i++) {
-      entity *se = get_union_member(st, i);
+      ir_entity *se = get_union_member(st, i);
       for (j = 0; j < get_union_n_members(lt); j++) {
-        entity *le = get_union_member(lt, j);
+        ir_entity *le = get_union_member(lt, j);
         if (get_entity_name(le) == get_entity_name(se))
           m[i] = le;
           }
@@ -764,12 +764,13 @@ ir_type *new_d_type_class (ident *name, dbg_info *db) {
 
   res = new_type(type_class, NULL, name, db);
 
-  res->attr.ca.members     = NEW_ARR_F (entity *, 0);
+  res->attr.ca.members     = NEW_ARR_F (ir_entity *, 0);
   res->attr.ca.subtypes    = NEW_ARR_F (ir_type *, 0);
   res->attr.ca.supertypes  = NEW_ARR_F (ir_type *, 0);
   res->attr.ca.peculiarity = peculiarity_existent;
   res->attr.ca.type_info   = NULL;
-  res->attr.ca.final       = 0;
+  res->attr.ca.vtable_size = 0;
+  res->attr.ca.clss_flags  = cf_none;
   res->attr.ca.dfn         = 0;
   hook_new_type(res);
   return res;
@@ -796,17 +797,17 @@ void free_class_attrs(ir_type *clss) {
 }
 
 /* manipulate private fields of class type  */
-void    add_class_member   (ir_type *clss, entity *member) {
+void    add_class_member   (ir_type *clss, ir_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);
+  ARR_APP1 (ir_entity *, clss->attr.ca.members, member);
 }
 
 int     (get_class_n_members) (const ir_type *clss) {
   return _get_class_n_members(clss);
 }
 
-int     get_class_member_index(const ir_type *clss, entity *mem) {
+int     get_class_member_index(const ir_type *clss, ir_entity *mem) {
   int i, n;
   assert(clss && (clss->type_op == type_class));
   for (i = 0, n = get_class_n_members(clss); i < n; ++i)
@@ -815,44 +816,44 @@ int     get_class_member_index(const ir_type *clss, entity *mem) {
   return -1;
 }
 
-entity *(get_class_member)   (const ir_type *clss, int pos) {
+ir_entity *(get_class_member)   (const ir_type *clss, int pos) {
   return _get_class_member(clss, pos);
 }
 
-entity *get_class_member_by_name(ir_type *clss, ident *name) {
+ir_entity *get_class_member_by_name(ir_type *clss, ident *name) {
   int i, n_mem;
   assert(clss && (clss->type_op == type_class));
   n_mem = get_class_n_members(clss);
   for (i = 0; i < n_mem; ++i) {
-    entity *mem = get_class_member(clss, i);
+    ir_entity *mem = get_class_member(clss, i);
     if (get_entity_ident(mem) == name) return mem;
   }
   return NULL;
 }
 
-void    set_class_member   (ir_type *clss, entity *member, int pos) {
+void    set_class_member   (ir_type *clss, ir_entity *member, int pos) {
   assert(clss && (clss->type_op == type_class));
   assert(pos >= 0 && pos < get_class_n_members(clss));
   clss->attr.ca.members[pos] = member;
 }
-void    set_class_members  (ir_type *clss, entity **members, int arity) {
+void    set_class_members  (ir_type *clss, ir_entity **members, int arity) {
   int i;
   assert(clss && (clss->type_op == type_class));
   DEL_ARR_F(clss->attr.ca.members);
-  clss->attr.ca.members    = NEW_ARR_F (entity *, 0);
+  clss->attr.ca.members    = NEW_ARR_F (ir_entity *, 0);
   for (i = 0; i < arity; i++) {
     set_entity_owner(members[i], clss);
-    ARR_APP1 (entity *, clss->attr.ca.members, members[i]);
+    ARR_APP1 (ir_entity *, clss->attr.ca.members, members[i]);
   }
 }
-void    remove_class_member(ir_type *clss, entity *member) {
+void    remove_class_member(ir_type *clss, ir_entity *member) {
   int i;
   assert(clss && (clss->type_op == type_class));
   for (i = 0; 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);
+      ARR_SETLEN(ir_entity*, clss->attr.ca.members, ARR_LEN(clss->attr.ca.members) - 1);
       break;
     }
   }
@@ -897,7 +898,7 @@ void    remove_class_subtype(ir_type *clss, ir_type *subtype) {
     if (clss->attr.ca.subtypes[i] == subtype) {
       for (; i < (ARR_LEN (clss->attr.ca.subtypes))-1; i++)
         clss->attr.ca.subtypes[i] = clss->attr.ca.subtypes[i+1];
-      ARR_SETLEN(entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1);
+      ARR_SETLEN(ir_entity*, clss->attr.ca.subtypes, ARR_LEN(clss->attr.ca.subtypes) - 1);
       break;
     }
 }
@@ -942,18 +943,20 @@ void    remove_class_supertype(ir_type *clss, ir_type *supertype) {
     if (clss->attr.ca.supertypes[i] == supertype) {
       for(; i < (ARR_LEN (clss->attr.ca.supertypes))-1; i++)
     clss->attr.ca.supertypes[i] = clss->attr.ca.supertypes[i+1];
-      ARR_SETLEN(entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
+      ARR_SETLEN(ir_entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
       break;
     }
 }
-entity *get_class_type_info(const ir_type *clss) {
+ir_entity *get_class_type_info(const ir_type *clss) {
   return clss->attr.ca.type_info;
 }
-void set_class_type_info(ir_type *clss, entity *ent) {
+void set_class_type_info(ir_type *clss, ir_entity *ent) {
   clss->attr.ca.type_info = ent;
+  if (ent)
+    ent->repr_class = clss;
 }
 
-const char *get_peculiarity_string(peculiarity p) {
+const char *get_peculiarity_name(ir_peculiarity p) {
 #define X(a)    case a: return #a
   switch (p) {
     X(peculiarity_description);
@@ -964,23 +967,55 @@ const char *get_peculiarity_string(peculiarity p) {
   return "invalid peculiarity";
 }
 
-peculiarity get_class_peculiarity (const ir_type *clss) {
+ir_peculiarity get_class_peculiarity (const ir_type *clss) {
   assert(clss && (clss->type_op == type_class));
   return clss->attr.ca.peculiarity;
 }
 
-void        set_class_peculiarity (ir_type *clss, peculiarity pec) {
+void        set_class_peculiarity (ir_type *clss, ir_peculiarity pec) {
   assert(clss && (clss->type_op == type_class));
   assert(pec != peculiarity_inherited);  /* There is no inheritance of types in libFirm. */
   clss->attr.ca.peculiarity = pec;
 }
 
+/* Returns the size of the virtual function table. */
+unsigned (get_class_vtable_size)(const ir_type *clss) {
+  return _get_class_vtable_size(clss);
+}
+
+/* Sets a new size of the virtual function table. */
+void (set_class_vtable_size)(ir_type *clss, unsigned size) {
+  _set_class_vtable_size(clss, size);
+}
+
+/* Returns non-zero if a class is final. */
 int (is_class_final)(const ir_type *clss) {
   return _is_class_final(clss);
 }
 
-void (set_class_final)(ir_type *clss, int final) {
-  _set_class_final(clss, final);
+/* Sets if a class is final. */
+void (set_class_final)(ir_type *clss, int flag) {
+  _set_class_final(clss, flag);
+}
+
+/* Returns non-zero if a class is an interface. */
+int (is_class_interface)(const ir_type *clss) {
+  return _is_class_interface(clss);
+}
+
+/* Sets the class interface flag. */
+void (set_class_interface)(ir_type *clss, int flag) {
+  _set_class_interface(clss, flag);
+}
+
+/* Returns non-zero if a class is abstract. */
+int (is_class_abstract)(const ir_type *clss) {
+  return _is_class_abstract(clss);
+}
+
+/* Sets the class abstract flag. */
+void (set_class_abstract)(ir_type *clss, int final) {
+  _set_class_abstract(clss, final);
 }
 
 void set_class_dfn (ir_type *clss, int dfn) {
@@ -1017,7 +1052,7 @@ void set_class_size_bits(ir_type *tp, int size) {
 ir_type *new_d_type_struct(ident *name, dbg_info *db) {
   ir_type *res = new_type(type_struct, NULL, name, db);
 
-  res->attr.sa.members = NEW_ARR_F(entity *, 0);
+  res->attr.sa.members = NEW_ARR_F(ir_entity *, 0);
   hook_new_type(res);
   return res;
 }
@@ -1043,21 +1078,21 @@ int     get_struct_n_members (const ir_type *strct) {
   return (ARR_LEN (strct->attr.sa.members));
 }
 
-void    add_struct_member   (ir_type *strct, entity *member) {
+void    add_struct_member   (ir_type *strct, ir_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);
+  ARR_APP1 (ir_entity *, strct->attr.sa.members, member);
 }
 
-entity *get_struct_member   (const ir_type *strct, int pos) {
+ir_entity *get_struct_member   (const ir_type *strct, int pos) {
   assert(strct && (strct->type_op == type_struct));
   assert(pos >= 0 && pos < get_struct_n_members(strct));
   return strct->attr.sa.members[pos];
 }
 
-int     get_struct_member_index(const ir_type *strct, entity *mem) {
+int     get_struct_member_index(const ir_type *strct, ir_entity *mem) {
   int i, n;
   assert(strct && (strct->type_op == type_struct));
   for (i = 0, n = get_struct_n_members(strct); i < n; ++i)
@@ -1066,20 +1101,20 @@ int     get_struct_member_index(const ir_type *strct, entity *mem) {
   return -1;
 }
 
-void    set_struct_member   (ir_type *strct, int pos, entity *member) {
+void    set_struct_member   (ir_type *strct, int pos, ir_entity *member) {
   assert(strct && (strct->type_op == type_struct));
   assert(pos >= 0 && pos < get_struct_n_members(strct));
   assert(get_entity_type(member)->type_op != type_method);/* @@@ lowerfirm !!*/
   strct->attr.sa.members[pos] = member;
 }
-void    remove_struct_member(ir_type *strct, entity *member) {
+void    remove_struct_member(ir_type *strct, ir_entity *member) {
   int i;
   assert(strct && (strct->type_op == type_struct));
   for (i = 0; i < (ARR_LEN (strct->attr.sa.members)); i++)
     if (strct->attr.sa.members[i] == member) {
       for(; i < (ARR_LEN (strct->attr.sa.members))-1; i++)
     strct->attr.sa.members[i] = strct->attr.sa.members[i+1];
-      ARR_SETLEN(entity*, strct->attr.sa.members, ARR_LEN(strct->attr.sa.members) - 1);
+      ARR_SETLEN(ir_entity*, strct->attr.sa.members, ARR_LEN(strct->attr.sa.members) - 1);
       break;
     }
 }
@@ -1119,13 +1154,20 @@ static INLINE ir_type *
 build_value_type(ident *name, int len, tp_ent_pair *tps) {
   int i;
   ir_type *res = new_type_struct(name);
+  res->flags |= tf_value_param_type;
   /* Remove type from type list.  Must be treated differently than other types. */
   remove_irp_type(res);
   for (i = 0; i < len; i++) {
+    ident *id = tps[i].param_name;
+
     /* use res as default if corresponding type is not yet set. */
     ir_type *elt_type = tps[i].tp ? tps[i].tp : res;
 
-    tps[i].ent = new_entity(res, mangle_u(name, get_type_ident(elt_type)), elt_type);
+    /* use the parameter name if specified */
+    if (! id)
+      id = mangle_u(name, get_type_ident(elt_type));
+    tps[i].ent = new_entity(res, id, elt_type);
+    set_entity_allocation(tps[i].ent, allocation_parameter);
   }
   return res;
 }
@@ -1140,7 +1182,7 @@ ir_type *new_d_type_method(ident *name, int n_param, int n_res, dbg_info *db) {
   res->flags                       |= tf_layout_fixed;
   res->size                         = get_mode_size_bits(mode_P_code);
   res->attr.ma.n_params             = n_param;
-  res->attr.ma.param_type           = xcalloc(n_param, sizeof(res->attr.ma.param_type[0]));
+  res->attr.ma.params               = xcalloc(n_param, sizeof(res->attr.ma.params[0]));
   res->attr.ma.value_params         = NULL;
   res->attr.ma.n_res                = n_res;
   res->attr.ma.res_type             = xcalloc(n_res, sizeof(res->attr.ma.res_type[0]));
@@ -1164,7 +1206,7 @@ void free_method_entities(ir_type *method) {
 /* Attention: also frees entities in value parameter subtypes! */
 void free_method_attrs(ir_type *method) {
   assert(method && (method->type_op == type_method));
-  free(method->attr.ma.param_type);
+  free(method->attr.ma.params);
   free(method->attr.ma.res_type);
   if (method->attr.ma.value_params) {
     free_type_entities(method->attr.ma.value_params);
@@ -1181,19 +1223,20 @@ int (get_method_n_params)(const ir_type *method) {
   return _get_method_n_params(method);
 }
 
+/* Returns the type of the parameter at position pos of a method. */
 ir_type *get_method_param_type(ir_type *method, int pos) {
   ir_type *res;
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
-  res = method->attr.ma.param_type[pos].tp;
+  res = method->attr.ma.params[pos].tp;
   assert(res != NULL && "empty method param type");
-  return method->attr.ma.param_type[pos].tp = skip_tid(res);
+  return method->attr.ma.params[pos].tp = skip_tid(res);
 }
 
 void  set_method_param_type(ir_type *method, int pos, ir_type *tp) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
-  method->attr.ma.param_type[pos].tp = tp;
+  method->attr.ma.params[pos].tp = tp;
   /* If information constructed set pass-by-value representation. */
   if (method->attr.ma.value_params) {
     assert(get_method_n_params(method) == get_struct_n_members(method->attr.ma.value_params));
@@ -1201,9 +1244,31 @@ void  set_method_param_type(ir_type *method, int pos, ir_type *tp) {
   }
 }
 
+/* Returns an ident representing the parameters name. Returns NULL if not set.
+   For debug support only. */
+ident *get_method_param_ident(ir_type *method, int pos) {
+  assert(method && (method->type_op == type_method));
+  assert(pos >= 0 && pos < get_method_n_params(method));
+  return method->attr.ma.params[pos].param_name;
+}
+
+/* Returns a string representing the parameters name. Returns NULL if not set.
+   For debug support only. */
+const char *get_method_param_name(ir_type *method, int pos) {
+  ident *id = get_method_param_ident(method, pos);
+  return id ? get_id_str(id) : NULL;
+}
+
+/* Sets an ident representing the parameters name. For debug support only. */
+void set_method_param_ident(ir_type *method, int pos, ident *id) {
+  assert(method && (method->type_op == type_method));
+  assert(pos >= 0 && pos < get_method_n_params(method));
+  method->attr.ma.params[pos].param_name = id;
+}
+
 /* Returns an entity that represents the copied value argument.  Only necessary
    for compounds passed by value. */
-entity *get_method_value_param_ent(ir_type *method, int pos) {
+ir_entity *get_method_value_param_ent(ir_type *method, int pos) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_params(method));
 
@@ -1211,15 +1276,15 @@ entity *get_method_value_param_ent(ir_type *method, int pos) {
     /* parameter value type not created yet, build */
     method->attr.ma.value_params
       = build_value_type(mangle_u(get_type_ident(method), value_params_suffix),
-             get_method_n_params(method), method->attr.ma.param_type);
+             get_method_n_params(method), method->attr.ma.params);
   }
   /*
    * build_value_type() sets the method->attr.ma.value_params type as default if
    * no type is set!
    */
-  assert((get_entity_type(method->attr.ma.param_type[pos].ent) != method->attr.ma.value_params)
+  assert((get_entity_type(method->attr.ma.params[pos].ent) != method->attr.ma.value_params)
      && "param type not yet set");
-  return method->attr.ma.param_type[pos].ent;
+  return method->attr.ma.params[pos].ent;
 }
 
 /*
@@ -1258,7 +1323,7 @@ void  set_method_res_type(ir_type *method, int pos, ir_type *tp) {
 
 /* Returns an entity that represents the copied value result.  Only necessary
    for compounds passed by value. */
-entity *get_method_value_res_ent(ir_type *method, int pos) {
+ir_entity *get_method_value_res_ent(ir_type *method, int pos) {
   assert(method && (method->type_op == type_method));
   assert(pos >= 0 && pos < get_method_n_ress(method));
 
@@ -1394,7 +1459,7 @@ int (is_Method_type)(const ir_type *method) {
 ir_type *new_d_type_union(ident *name, dbg_info *db) {
   ir_type *res = new_type(type_union, NULL, name, db);
 
-  res->attr.ua.members = NEW_ARR_F(entity *, 0);
+  res->attr.ua.members = NEW_ARR_F(ir_entity *, 0);
   hook_new_type(res);
   return res;
 }
@@ -1420,17 +1485,17 @@ int    get_union_n_members      (const ir_type *uni) {
   assert(uni && (uni->type_op == type_union));
   return (ARR_LEN (uni->attr.ua.members));
 }
-void    add_union_member   (ir_type *uni, entity *member) {
+void    add_union_member   (ir_type *uni, ir_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);
+  ARR_APP1 (ir_entity *, uni->attr.ua.members, member);
 }
-entity  *get_union_member (const ir_type *uni, int pos) {
+ir_entity  *get_union_member (const ir_type *uni, int pos) {
   assert(uni && (uni->type_op == type_union));
   assert(pos >= 0 && pos < get_union_n_members(uni));
   return uni->attr.ua.members[pos];
 }
-int     get_union_member_index(const ir_type *uni, entity *mem) {
+int     get_union_member_index(const ir_type *uni, ir_entity *mem) {
   int i, n;
   assert(uni && (uni->type_op == type_union));
   for (i = 0, n = get_union_n_members(uni); i < n; ++i)
@@ -1438,19 +1503,19 @@ int     get_union_member_index(const ir_type *uni, entity *mem) {
       return i;
   return -1;
 }
-void   set_union_member (ir_type *uni, int pos, entity *member) {
+void   set_union_member (ir_type *uni, int pos, ir_entity *member) {
   assert(uni && (uni->type_op == type_union));
   assert(pos >= 0 && pos < get_union_n_members(uni));
   uni->attr.ua.members[pos] = member;
 }
-void   remove_union_member(ir_type *uni, entity *member) {
+void   remove_union_member(ir_type *uni, ir_entity *member) {
   int i;
   assert(uni && (uni->type_op == type_union));
   for (i = 0; i < (ARR_LEN (uni->attr.ua.members)); i++)
     if (uni->attr.ua.members[i] == member) {
       for(; i < (ARR_LEN (uni->attr.ua.members))-1; i++)
         uni->attr.ua.members[i] = uni->attr.ua.members[i+1];
-      ARR_SETLEN(entity*, uni->attr.ua.members, ARR_LEN(uni->attr.ua.members) - 1);
+      ARR_SETLEN(ir_entity*, uni->attr.ua.members, ARR_LEN(uni->attr.ua.members) - 1);
       break;
     }
 }
@@ -1518,6 +1583,7 @@ void free_array_attrs (ir_type *array) {
   assert(array && (array->type_op == type_array));
   free(array->attr.aa.lower_bound);
   free(array->attr.aa.upper_bound);
+  free(array->attr.aa.order);
 }
 
 /* manipulate private fields of array ir_type */
@@ -1635,13 +1701,13 @@ ir_type *get_array_element_type (ir_type *array) {
   return array->attr.aa.element_type = skip_tid(array->attr.aa.element_type);
 }
 
-void  set_array_element_entity (ir_type *array, entity *ent) {
+void  set_array_element_entity (ir_type *array, ir_entity *ent) {
   assert(array && (array->type_op == type_array));
   assert((get_entity_type(ent)->type_op != type_method));
   array->attr.aa.element_ent = ent;
   array->attr.aa.element_type = get_entity_type(ent);
 }
-entity *get_array_element_entity (const ir_type *array) {
+ir_entity *get_array_element_entity (const ir_type *array) {
   assert(array && (array->type_op == type_array));
   return array->attr.aa.element_ent;
 }
@@ -1661,11 +1727,11 @@ void set_array_size_bits(ir_type *tp, int size) {
 
 /* create a new type enumeration -- set the enumerators independently */
 ir_type *new_d_type_enumeration(ident *name, int n_enums, dbg_info *db) {
-  ir_type *res = new_type(type_enumeration, NULL, name, db);
+  ir_type *res;
 
-  res->attr.ea.n_enums     = 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]));
+  assert(n_enums >= 0);
+  res = new_type(type_enumeration, NULL, name, db);
+  res->attr.ea.enumer = NEW_ARR_F(ir_enum_const, n_enums);
   hook_new_type(res);
   return res;
 }
@@ -1679,39 +1745,46 @@ void free_enumeration_entities(ir_type *enumeration) {
 }
 void free_enumeration_attrs(ir_type *enumeration) {
   assert(enumeration && (enumeration->type_op == type_enumeration));
-  free(enumeration->attr.ea.enumer);
-  free(enumeration->attr.ea.enum_nameid);
+  DEL_ARR_F(enumeration->attr.ea.enumer);
 }
 
 /* manipulate fields of enumeration type. */
-int     get_enumeration_n_enums (const ir_type *enumeration) {
+int     get_enumeration_n_enums(const ir_type *enumeration) {
   assert(enumeration && (enumeration->type_op == type_enumeration));
-  return enumeration->attr.ea.n_enums;
+  return ARR_LEN(enumeration->attr.ea.enumer);
 }
-void    set_enumeration_enum    (ir_type *enumeration, int pos, tarval *con) {
-  assert(enumeration && (enumeration->type_op == type_enumeration));
-  assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
-  enumeration->attr.ea.enumer[pos] = con;
+
+/* create a new constant */
+void set_enumeration_const(ir_type *enumeration, int pos, ident *nameid, tarval *con) {
+  assert(0 <= pos && pos < ARR_LEN(enumeration->attr.ea.enumer));
+  enumeration->attr.ea.enumer[pos].nameid = nameid;
+  enumeration->attr.ea.enumer[pos].value  = con;
+  enumeration->attr.ea.enumer[pos].owner  = enumeration;
 }
-tarval *get_enumeration_enum    (const ir_type *enumeration, int pos) {
+
+ir_enum_const *get_enumeration_const(const ir_type *enumeration, int pos) {
   assert(enumeration && (enumeration->type_op == type_enumeration));
   assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
-  return enumeration->attr.ea.enumer[pos];
+  return &enumeration->attr.ea.enumer[pos];
 }
-void    set_enumeration_nameid  (ir_type *enumeration, int pos, ident *id) {
-  assert(enumeration && (enumeration->type_op == type_enumeration));
-  assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
-  enumeration->attr.ea.enum_nameid[pos] = id;
+
+ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst) {
+  return enum_cnst->owner;
 }
-ident  *get_enumeration_nameid  (const ir_type *enumeration, int pos) {
-  assert(enumeration && (enumeration->type_op == type_enumeration));
-  assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
-  return enumeration->attr.ea.enum_nameid[pos];
+void    set_enumeration_value(ir_enum_const *enum_cnst, tarval *con) {
+  enum_cnst->value = con;
 }
-const char *get_enumeration_name(const ir_type *enumeration, int pos) {
-  assert(enumeration && (enumeration->type_op == type_enumeration));
-  assert(pos >= 0 && pos < get_enumeration_n_enums(enumeration));
-  return get_id_str(enumeration->attr.ea.enum_nameid[pos]);
+tarval *get_enumeration_value(const ir_enum_const *enum_cnst) {
+  return enum_cnst->value;
+}
+void    set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id) {
+  enum_cnst->nameid = id;
+}
+ident  *get_enumeration_nameid(const ir_enum_const *enum_cnst) {
+  return enum_cnst->nameid;
+}
+const char *get_enumeration_name(const ir_enum_const *enum_cnst) {
+  return get_id_str(enum_cnst->nameid);
 }
 
 /* typecheck */
@@ -1787,8 +1860,8 @@ void set_pointer_mode(ir_type *tp, ir_mode *mode) {
  *  Not efficient: O(#types).
  *  If not found returns firm_unknown_type. */
 ir_type *find_pointer_type_to_type (ir_type *tp) {
-  int i;
-  for (i = 0; i < get_irp_n_types(); ++i) {
+  int i, n = get_irp_n_types();
+  for (i = 0; i < n; ++i) {
     ir_type *found = get_irp_type(i);
     if (is_Pointer_type(found) && get_pointer_points_to_type(found) == tp)
       return (found);
@@ -1859,10 +1932,10 @@ int get_compound_n_members(const ir_type *tp)
 /*
  * Gets the member of a firm compound type at position pos.
  */
-entity *get_compound_member(const ir_type *tp, int pos)
+ir_entity *get_compound_member(const ir_type *tp, int pos)
 {
   const tp_op *op = get_type_tpop(tp);
-  entity *res = NULL;
+  ir_entity *res = NULL;
 
   if (op->ops.get_member)
     res = op->ops.get_member(tp, pos);
@@ -1873,7 +1946,7 @@ entity *get_compound_member(const ir_type *tp, int pos)
 }
 
 /* Returns index of member in tp, -1 if not contained. */
-int get_compound_member_index(const ir_type *tp, entity *member)
+int get_compound_member_index(const ir_type *tp, ir_entity *member)
 {
   const tp_op *op = get_type_tpop(tp);
   int index = -1;
@@ -1891,12 +1964,17 @@ int is_compound_type(const ir_type *tp) {
   return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
 }
 
-/* Checks, whether a type is a frame ir_type */
+/* Checks, whether a type is a frame type */
 int is_frame_type(const ir_type *tp) {
   return tp->flags & tf_frame_type;
 }
 
-/* Checks, whether a type is a lowered ir_type */
+/* Checks, whether a type is a value parameter type */
+int is_value_param_type(const ir_type *tp) {
+  return tp->flags & tf_value_param_type;
+}
+
+/* Checks, whether a type is a lowered type */
 int is_lowered_type(const ir_type *tp) {
   return tp->flags & tf_lowered_type;
 }
@@ -1911,6 +1989,9 @@ ir_type *new_type_frame(ident *name)
   /* Remove type from type list.  Must be treated differently than other types. */
   remove_irp_type(res);
 
+  /* It is not possible to derive from the frame type. Set the final flag. */
+  set_class_final(res, 1);
+
   return res;
 }
 
@@ -1934,3 +2015,62 @@ ir_type *get_associated_type(const ir_type *tp) {
 void set_default_size_bits(ir_type *tp, int size) {
   tp->size = size;
 }
+
+/*
+ * Allocate an area of size bytes aligned at alignment
+ * at the start or the end of a frame type.
+ * The frame type must have already an fixed layout.
+ */
+ir_entity *frame_alloc_area(ir_type *frame_type, int size, int alignment, int at_start)
+{
+  ir_entity *area;
+  ir_type *tp;
+  ident *name;
+  char buf[32];
+  int frame_align, i, offset, frame_size;
+  static unsigned area_cnt = 0;
+  static ir_type *a_byte = NULL;
+
+  assert(is_frame_type(frame_type));
+  assert(get_type_state(frame_type) == layout_fixed);
+
+  if (! a_byte)
+    a_byte = new_type_primitive(new_id_from_chars("byte", 4), mode_Bu);
+
+  snprintf(buf, sizeof(buf), "area%u", area_cnt++);
+  name = new_id_from_str(buf);
+
+  /* align the size */
+  frame_align = get_type_alignment_bytes(frame_type);
+  size = (size + frame_align - 1) & -frame_align;
+
+  tp = new_type_array(mangle_u(get_type_ident(frame_type), name), 1, a_byte);
+  set_array_bounds_int(tp, 0, 0, size);
+  set_type_alignment_bytes(tp, alignment);
+
+  frame_size = get_type_size_bytes(frame_type);
+  if (at_start) {
+    /* fix all offsets so far */
+    for (i = get_class_n_members(frame_type) - 1; i >= 0; --i) {
+      ir_entity *ent = get_class_member(frame_type, i);
+
+      set_entity_offset(ent, get_entity_offset(ent) + size);
+    }
+    /* calculate offset and new type size */
+    offset = 0;
+    frame_size += size;
+  }
+  else {
+    /* calculate offset and new type size */
+    offset = (frame_size + alignment - 1) & -alignment;
+    frame_size = offset + size;
+  }
+
+  area = new_entity(frame_type, name, tp);
+  set_entity_offset(area, offset);
+  set_type_size_bytes(frame_type, frame_size);
+
+  /* mark this entity as compiler generated */
+  set_entity_compiler_generated(area, 1);
+  return area;
+}