X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftype.c;h=77020be977a32fefaaa65b3b167703869af3c2f0;hb=288b414e4d82e0aa0d4b4348d8c387db02142cdb;hp=f208cbb00d1cab4f1d0070d99cc8b0115ff24eee;hpb=8d8024e059a27e16d93eaa07d38146ab85c16204;p=libfirm

diff --git a/ir/tr/type.c b/ir/tr/type.c
index f208cbb00..77020be97 100644
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -45,17 +45,10 @@
  * @see  type_t.h type tpop
  */
 
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#ifdef HAVE_STRING_H
-# include <string.h>
-#endif
-#ifdef HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
+#include "config.h"
 
+#include <string.h>
+#include <stdlib.h>
 #include <stddef.h>
 
 #include "type_t.h"
@@ -76,6 +69,7 @@
 /*-----------------------------------------------------------------*/
 
 ir_type *firm_none_type;    ir_type *get_none_type(void)    { return firm_none_type;    }
+ir_type *firm_code_type;    ir_type *get_code_type(void)    { return firm_code_type;    }
 ir_type *firm_unknown_type; ir_type *get_unknown_type(void) { return firm_unknown_type; }
 
 
@@ -99,28 +93,32 @@ void firm_init_type(dbg_info *builtin_db, unsigned def_cc_mask) {
 
 	/* construct none and unknown type. */
 	firm_none_type    = new_type(tpop_none,    mode_BAD, new_id_from_str("type_none"), builtin_db);
-	set_type_size_bits(firm_none_type, 0);
+	set_type_size_bytes(firm_none_type, 0);
 	set_type_state (firm_none_type, layout_fixed);
 	remove_irp_type(firm_none_type);
 
+	firm_code_type    = new_type(tpop_code, mode_ANY, new_id_from_str("type_code"), builtin_db);
+	set_type_state(firm_code_type, layout_fixed);
+	remove_irp_type(firm_code_type);
+
 	firm_unknown_type = new_type(tpop_unknown, mode_ANY, new_id_from_str("type_unknown"), builtin_db);
-	set_type_size_bits(firm_unknown_type, 0);
+	set_type_size_bytes(firm_unknown_type, 0);
 	set_type_state (firm_unknown_type, layout_fixed);
 	remove_irp_type(firm_unknown_type);
 }
 
 /** the global type visited flag */
-unsigned long firm_type_visited;
+ir_visited_t firm_type_visited;
 
-void (set_master_type_visited)(unsigned long val) { _set_master_type_visited(val); }
-unsigned long (get_master_type_visited)(void)     { return _get_master_type_visited(); }
-void (inc_master_type_visited)(void)              { _inc_master_type_visited(); }
+void (set_master_type_visited)(ir_visited_t val) { _set_master_type_visited(val); }
+ir_visited_t (get_master_type_visited)(void)     { return _get_master_type_visited(); }
+void (inc_master_type_visited)(void)             { _inc_master_type_visited(); }
 
 /*
  * Creates a new type representation.
  */
 ir_type *
-new_type(tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
+new_type(const tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
 	ir_type *res;
 	int node_size;
 
@@ -137,8 +135,8 @@ new_type(tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
 	res->name       = name;
 	res->visibility = visibility_external_allocated;
 	res->flags      = tf_none;
-	res->size       = -1;
-	res->align      = -1;
+	res->size       = 0;
+	res->align      = 0;
 	res->visit      = 0;
 	res->link       = NULL;
 	res->dbi        = db;
@@ -155,7 +153,8 @@ new_type(tp_op *type_op, ir_mode *mode, ident *name, dbg_info *db) {
 void free_type(ir_type *tp) {
 	const tp_op *op = get_type_tpop(tp);
 
-	if ((get_type_tpop(tp) == tpop_none) || (get_type_tpop(tp) == tpop_unknown))
+	if ((get_type_tpop(tp) == tpop_none) || (get_type_tpop(tp) == tpop_unknown)
+			|| (get_type_tpop(tp) == tpop_code))
 		return;
 	/* Remove from list of all types */
 	remove_irp_type(tp);
@@ -245,15 +244,10 @@ const char *get_type_name(const ir_type *tp) {
 	return (get_id_str(tp->name));
 }
 
-int (get_type_size_bytes)(const ir_type *tp) {
+unsigned (get_type_size_bytes)(const ir_type *tp) {
 	return _get_type_size_bytes(tp);
 }
 
-int (get_type_size_bits)(const ir_type *tp) {
-	return _get_type_size_bits(tp);
-}
-
-
 ir_visibility get_type_visibility(const ir_type *tp) {
 #if 0
 	visibility res =  visibility_local;
@@ -305,7 +299,7 @@ void set_type_visibility(ir_type *tp, ir_visibility v) {
 }
 
 void
-set_type_size_bits(ir_type *tp, int size) {
+set_type_size_bytes(ir_type *tp, unsigned size) {
 	const tp_op *tpop = get_type_tpop(tp);
 
 	if (tpop->ops.set_type_size)
@@ -314,35 +308,24 @@ set_type_size_bits(ir_type *tp, int size) {
 		assert(0 && "Cannot set size for this type");
 }
 
-void
-set_type_size_bytes(ir_type *tp, int size) {
-	set_type_size_bits(tp, 8*size);
-}
-
-int get_type_alignment_bytes(ir_type *tp) {
-	int align = get_type_alignment_bits(tp);
-
-	return align < 0 ? align : (align + 7) >> 3;
-}
-
-int get_type_alignment_bits(ir_type *tp) {
-	int align = 8;
+unsigned get_type_alignment_bytes(ir_type *tp) {
+	unsigned align = 1;
 
 	if (tp->align > 0)
 		return tp->align;
 
 	/* alignment NOT set calculate it "on demand" */
 	if (tp->mode)
-		align = get_mode_size_bits(tp->mode);
+		align = (get_mode_size_bits(tp->mode) + 7) >> 3;
 	else if (is_Array_type(tp))
-		align = get_type_alignment_bits(get_array_element_type(tp));
+		align = get_type_alignment_bytes(get_array_element_type(tp));
 	else if (is_compound_type(tp)) {
 		int i, n = get_compound_n_members(tp);
 
 		align = 0;
 		for (i = 0; i < n; ++i) {
-			ir_type *t = get_entity_type(get_compound_member(tp, i));
-			int   a = get_type_alignment_bits(t);
+			ir_type  *t = get_entity_type(get_compound_member(tp, i));
+			unsigned a  = get_type_alignment_bytes(t);
 
 			if (a > align)
 				align = a;
@@ -358,26 +341,16 @@ int get_type_alignment_bits(ir_type *tp) {
 }
 
 void
-set_type_alignment_bits(ir_type *tp, int align) {
+set_type_alignment_bytes(ir_type *tp, unsigned 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;
 	}
 }
 
-void
-set_type_alignment_bytes(ir_type *tp, int 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. */
-const char *get_type_state_name(type_state s) {
+const char *get_type_state_name(ir_type_state s) {
 #define X(a)    case a: return #a;
 	switch (s) {
 		X(layout_undefined);
@@ -388,12 +361,12 @@ const char *get_type_state_name(type_state s) {
 }
 
 
-type_state (get_type_state)(const ir_type *tp) {
+ir_type_state (get_type_state)(const ir_type *tp) {
 	return _get_type_state(tp);
 }
 
 void
-set_type_state(ir_type *tp, type_state state) {
+set_type_state(ir_type *tp, ir_type_state state) {
 	assert(tp && tp->kind == k_type);
 
 	if ((tp->type_op == type_pointer) || (tp->type_op == type_primitive) ||
@@ -405,7 +378,6 @@ 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++) {
@@ -418,7 +390,6 @@ set_type_state(ir_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(get_struct_member(tp, i)) > -1);
 				assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
@@ -451,11 +422,11 @@ set_type_state(ir_type *tp, type_state state) {
 		tp->flags &= ~tf_layout_fixed;
 }
 
-unsigned long (get_type_visited)(const ir_type *tp) {
+ir_visited_t (get_type_visited)(const ir_type *tp) {
 	return _get_type_visited(tp);
 }
 
-void (set_type_visited)(ir_type *tp, unsigned long num) {
+void (set_type_visited)(ir_type *tp, ir_visited_t num) {
 	_set_type_visited(tp, num);
 }
 
@@ -472,6 +443,14 @@ int (type_not_visited)(const ir_type *tp) {
 	return _type_not_visited(tp);
 }
 
+dbg_info *(get_type_dbg_info)(const ir_type *tp) {
+	return _get_type_dbg_info(tp);
+}
+
+void (set_type_dbg_info)(ir_type *tp, dbg_info *db) {
+	_set_type_dbg_info(tp, db);
+}
+
 int (is_type)(const void *thing) {
   return _is_type(thing);
 }
@@ -490,7 +469,7 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
 	    (get_type_state(typ1) != get_type_state(typ2)))
 		return 0;
 	if ((get_type_state(typ1) == layout_fixed) &&
-		(get_type_size_bits(typ1) != get_type_size_bits(typ2)))
+		(get_type_size_bytes(typ1) != get_type_size_bytes(typ2)))
 		return 0;
 
 	switch (get_type_tpop_code(typ1)) {
@@ -500,8 +479,7 @@ 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(ir_entity *) * get_class_n_members(typ1));
-		memset(m, 0, sizeof(ir_entity *) * get_class_n_members(typ1));
+		m = ALLOCANZ(ir_entity*, get_class_n_members(typ1));
 		/* First sort the members of typ2 */
 		for (i = 0; i < get_class_n_members(typ1); i++) {
 			ir_entity *e1 = get_class_member(typ1, i);
@@ -517,8 +495,7 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
 				return 0;
 		}
 		/** Compare the supertypes **/
-		t = alloca(sizeof(ir_entity *) * get_class_n_supertypes(typ1));
-		memset(t, 0, sizeof(ir_entity *) * get_class_n_supertypes(typ1));
+		t = ALLOCANZ(ir_type*, 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);
@@ -537,8 +514,7 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
 
 	case tpo_struct:
 		if (get_struct_n_members(typ1) != get_struct_n_members(typ2)) return 0;
-		m = alloca(sizeof(ir_entity *) * get_struct_n_members(typ1));
-		memset(m, 0, sizeof(ir_entity *) * get_struct_n_members(typ1));
+		m = ALLOCANZ(ir_entity*, get_struct_n_members(typ1));
 		/* First sort the members of lt */
 		for (i = 0; i < get_struct_n_members(typ1); i++) {
 			ir_entity *e1 = get_struct_member(typ1, i);
@@ -585,8 +561,7 @@ int equal_type(ir_type *typ1, ir_type *typ2) {
 
 	case tpo_union:
 		if (get_union_n_members(typ1) != get_union_n_members(typ2)) return 0;
-		m = alloca(sizeof(ir_entity *) * get_union_n_members(typ1));
-		memset(m, 0, sizeof(ir_entity *) * get_union_n_members(typ1));
+		m = ALLOCANZ(ir_entity*, get_union_n_members(typ1));
 		/* First sort the members of lt */
 		for (i = 0; i < get_union_n_members(typ1); i++) {
 			ir_entity *e1 = get_union_member(typ1, i);
@@ -653,8 +628,7 @@ int smaller_type(ir_type *st, ir_type *lt) {
 		if (n_st_members != get_struct_n_members(lt))
 			return 0;
 
-		m = alloca(sizeof(ir_entity *) * n_st_members);
-		memset(m, 0, sizeof(ir_entity *) * n_st_members);
+		m = ALLOCANZ(ir_entity*, n_st_members);
 		/* First sort the members of lt */
 		for (i = 0; i < n_st_members; ++i) {
 			ir_entity *se = get_struct_member(st, i);
@@ -704,8 +678,7 @@ int smaller_type(ir_type *st, ir_type *lt) {
 	case tpo_union:
 		n_st_members = get_union_n_members(st);
 		if (n_st_members != get_union_n_members(lt)) return 0;
-		m = alloca(sizeof(ir_entity *) * n_st_members);
-		memset(m, 0, sizeof(ir_entity *) * n_st_members);
+		m = ALLOCANZ(ir_entity*, n_st_members);
 		/* First sort the members of lt */
 		for (i = 0; i < n_st_members; ++i) {
 			ir_entity *se = get_union_member(st, i);
@@ -738,7 +711,7 @@ int smaller_type(ir_type *st, ir_type *lt) {
 			    (get_type_state(let) != layout_fixed))
 				return 0;
 			if (!smaller_type(set, let) ||
-			    get_type_size_bits(set) != get_type_size_bits(let))
+			    get_type_size_bytes(set) != get_type_size_bytes(let))
 				return 0;
 		}
 		for(i = 0; i < get_array_n_dimensions(st); i++) {
@@ -816,6 +789,7 @@ void free_class_attrs(ir_type *clss) {
 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");
+	assert(get_type_state(clss) != layout_fixed);
 	ARR_APP1 (ir_entity *, clss->attr.ca.members, member);
 }
 
@@ -1064,14 +1038,12 @@ int (is_Class_type)(const ir_type *clss) {
 void set_class_mode(ir_type *tp, ir_mode *mode) {
 	/* for classes and structs we allow to set a mode if the layout is fixed AND the size matches */
 	assert(get_type_state(tp) == layout_fixed &&
-	       tp->size == get_mode_size_bits(mode) && "mode don't match class layout");
+	       tp->size == get_mode_size_bytes(mode) && "mode don't match class layout");
 	tp->mode = mode;
 }
 
-void set_class_size_bits(ir_type *tp, int size) {
-	/* argh: we must allow to set negative values as "invalid size" */
-	tp->size = (size >= 0) ? (size + 7) & ~7 : size;
-	assert(tp->size == size && "setting a bit size is NOT allowed for this type");
+void set_class_size(ir_type *tp, unsigned size) {
+	tp->size = size;
 }
 
 /*----------------------------------------------------------------**/
@@ -1113,6 +1085,7 @@ 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);
 	assert(strct != get_entity_type(member) && "recursive type");
+	assert(get_type_state(strct) != layout_fixed);
 	ARR_APP1 (ir_entity *, strct->attr.sa.members, member);
 }
 
@@ -1158,14 +1131,12 @@ int (is_Struct_type)(const ir_type *strct) {
 void set_struct_mode(ir_type *tp, ir_mode *mode) {
 	/* for classes and structs we allow to set a mode if the layout is fixed AND the size matches */
 	assert(get_type_state(tp) == layout_fixed &&
-	       tp->size == get_mode_size_bits(mode) && "mode don't match struct layout");
+	       tp->size == get_mode_size_bytes(mode) && "mode don't match struct layout");
 	tp->mode = mode;
 }
 
-void set_struct_size_bits(ir_type *tp, int size) {
-	/* argh: we must allow to set negative values as "invalid size" */
-	tp->size = (size >= 0) ? (size + 7) & ~7 : size;
-	assert(tp->size == size && "setting a bit size is NOT allowed for this type");
+void set_struct_size(ir_type *tp, unsigned size) {
+	tp->size = size;
 }
 
 /*******************************************************************/
@@ -1196,7 +1167,7 @@ build_value_type(ident *name, int len, tp_ent_pair *tps) {
 
 		/* use the parameter name if specified */
 		if (! id)
-			id = mangle_u(name, get_type_ident(elt_type));
+			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);
 	}
@@ -1208,15 +1179,15 @@ build_value_type(ident *name, int len, tp_ent_pair *tps) {
 ir_type *new_d_type_method(ident *name, int n_param, int n_res, dbg_info *db) {
 	ir_type *res;
 
-	assert((get_mode_size_bytes(mode_P_code) != -1) && "unorthodox modes not implemented");
+	assert((get_mode_size_bits(mode_P_code) % 8 == 0) && "unorthodox modes not implemented");
 	res = new_type(type_method, mode_P_code, name, db);
 	res->flags                       |= tf_layout_fixed;
-	res->size                         = get_mode_size_bits(mode_P_code);
+	res->size                         = get_mode_size_bytes(mode_P_code);
 	res->attr.ma.n_params             = n_param;
-	res->attr.ma.params               = xcalloc(n_param, sizeof(res->attr.ma.params[0]));
+	res->attr.ma.params               = XMALLOCNZ(tp_ent_pair, n_param);
 	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]));
+	res->attr.ma.res_type             = XMALLOCNZ(tp_ent_pair, n_res);
 	res->attr.ma.value_ress           = NULL;
 	res->attr.ma.variadicity          = variadicity_non_variadic;
 	res->attr.ma.first_variadic_param = -1;
@@ -1230,7 +1201,48 @@ ir_type *new_type_method(ident *name, int n_param, int n_res) {
 	return new_d_type_method(name, n_param, n_res, NULL);
 }
 
+/* clone an existing method type */
+ir_type *clone_type_method(ir_type *tp, ident *prefix) {
+	ir_type  *res;
+	ident    *name;
+	ir_mode  *mode;
+	int      n_params, n_res;
+	dbg_info *db;
+
+	assert(is_Method_type(tp));
+
+	name = tp->name;
+	if (prefix != NULL)
+		name = id_mangle(prefix, name);
+
+	mode     = tp->mode;
+	n_params = tp->attr.ma.n_params;
+	n_res    = tp->attr.ma.n_res;
+	db       = tp->dbi;
+
+	res = new_type(type_method, mode, name, db);
+
+	res->flags                         = tp->flags;
+	res->assoc_type                    = tp->assoc_type;
+	res->size                          = tp->size;
+	res->attr.ma.n_params              = n_params;
+	res->attr.ma.params                = XMALLOCN(tp_ent_pair, n_params);
+	memcpy(res->attr.ma.params, tp->attr.ma.params, n_params * sizeof(res->attr.ma.params[0]));
+	res->attr.ma.value_params          = tp->attr.ma.value_params;
+	res->attr.ma.n_res                 = n_res;
+	res->attr.ma.res_type              = XMALLOCN(tp_ent_pair, n_res);
+	memcpy(res->attr.ma.res_type, tp->attr.ma.res_type, n_res * sizeof(res->attr.ma.res_type[0]));
+	res->attr.ma.value_ress            = tp->attr.ma.value_ress;
+	res->attr.ma.variadicity           = tp->attr.ma.variadicity;
+	res->attr.ma.first_variadic_param  = tp->attr.ma.first_variadic_param;
+	res->attr.ma.additional_properties = tp->attr.ma.additional_properties;
+	res->attr.ma.irg_calling_conv      = tp->attr.ma.irg_calling_conv;
+	hook_new_type(res);
+	return res;
+}
+
 void free_method_entities(ir_type *method) {
+  (void) method;
 	assert(method && (method->type_op == type_method));
 }
 
@@ -1239,10 +1251,12 @@ void free_method_attrs(ir_type *method) {
 	assert(method && (method->type_op == type_method));
 	free(method->attr.ma.params);
 	free(method->attr.ma.res_type);
+	/* cannot free it yet, type could be cloned ...
 	if (method->attr.ma.value_params) {
 		free_type_entities(method->attr.ma.value_params);
 		free_type(method->attr.ma.value_params);
 	}
+	*/
 	if (method->attr.ma.value_ress) {
 		free_type_entities(method->attr.ma.value_ress);
 		free_type(method->attr.ma.value_ress);
@@ -1306,7 +1320,7 @@ ir_entity *get_method_value_param_ent(ir_type *method, int pos) {
 	if (!method->attr.ma.value_params) {
 		/* parameter value type not created yet, build */
 		method->attr.ma.value_params
-			= build_value_type(mangle_u(get_type_ident(method), value_params_suffix),
+			= build_value_type(id_mangle_u(get_type_ident(method), value_params_suffix),
 			get_method_n_params(method), method->attr.ma.params);
 	}
 	/*
@@ -1318,6 +1332,26 @@ ir_entity *get_method_value_param_ent(ir_type *method, int pos) {
 	return method->attr.ma.params[pos].ent;
 }
 
+/*
+ * Sets the type that represents the copied value arguments.
+ */
+void set_method_value_param_type(ir_type *method, ir_type *tp) {
+	int i, n;
+
+	assert(method && (method->type_op == type_method));
+	assert(is_value_param_type(tp));
+	assert(get_method_n_params(method) == get_struct_n_members(tp));
+
+	method->attr.ma.value_params = tp;
+
+	n = get_struct_n_members(tp);
+	for (i = 0; i < n; i++)
+	{
+		ir_entity *ent = get_struct_member(tp, i);
+		method->attr.ma.params[i].ent = ent;
+	}
+}
+
 /*
  * Returns a type that represents the copied value arguments.
  */
@@ -1360,7 +1394,7 @@ ir_entity *get_method_value_res_ent(ir_type *method, int pos) {
 	if (!method->attr.ma.value_ress) {
 		/* result value type not created yet, build */
 		method->attr.ma.value_ress
-			= build_value_type(mangle_u(get_type_ident(method), value_ress_suffix),
+			= build_value_type(id_mangle_u(get_type_ident(method), value_ress_suffix),
 			get_method_n_ress(method), method->attr.ma.res_type);
 	}
 	/*
@@ -1382,7 +1416,7 @@ ir_type *get_method_value_res_type(const ir_type *method) {
 }
 
 /* Returns the null-terminated name of this variadicity. */
-const char *get_variadicity_name(variadicity vari) {
+const char *get_variadicity_name(ir_variadicity vari) {
 #define X(a)    case a: return #a
 	switch (vari) {
 	X(variadicity_non_variadic);
@@ -1393,12 +1427,12 @@ const char *get_variadicity_name(variadicity vari) {
 #undef X
 }
 
-variadicity get_method_variadicity(const ir_type *method) {
+ir_variadicity get_method_variadicity(const ir_type *method) {
 	assert(method && (method->type_op == type_method));
 	return method->attr.ma.variadicity;
 }
 
-void set_method_variadicity(ir_type *method, variadicity vari) {
+void set_method_variadicity(ir_type *method, ir_variadicity vari) {
 	assert(method && (method->type_op == type_method));
 	method->attr.ma.variadicity = vari;
 }
@@ -1514,6 +1548,7 @@ int get_union_n_members(const ir_type *uni) {
 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");
+	assert(get_type_state(uni) != layout_fixed);
 	ARR_APP1(ir_entity *, uni->attr.ua.members, member);
 }
 
@@ -1555,10 +1590,8 @@ int (is_Union_type)(const ir_type *uni) {
 	return _is_union_type(uni);
 }
 
-void set_union_size_bits(ir_type *tp, int size) {
-	/* argh: we must allow to set negative values as "invalid size" */
-	tp->size = (size >= 0) ? (size + 7) & ~7 : size;
-	assert(tp->size == size && "setting a bit size is NOT allowed for this type");
+void set_union_size(ir_type *tp, unsigned size) {
+	tp->size = size;
 }
 
 /*-----------------------------------------------------------------*/
@@ -1577,9 +1610,9 @@ ir_type *new_d_type_array(ident *name, int n_dimensions, ir_type *element_type,
 
 	res = new_type(type_array, NULL, name, db);
 	res->attr.aa.n_dimensions = 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));
+	res->attr.aa.lower_bound  = XMALLOCNZ(ir_node*, n_dimensions);
+	res->attr.aa.upper_bound  = XMALLOCNZ(ir_node*, n_dimensions);
+	res->attr.aa.order        = XMALLOCNZ(int,      n_dimensions);
 
 	current_ir_graph = get_const_code_irg();
 	unk = new_Unknown(mode_Iu);
@@ -1591,7 +1624,7 @@ ir_type *new_d_type_array(ident *name, int n_dimensions, ir_type *element_type,
 	current_ir_graph = rem;
 
 	res->attr.aa.element_type = element_type;
-	new_entity(res, mangle_u(name, new_id_from_chars("elem_ent", 8)), element_type);
+	new_entity(res, id_mangle_u(name, new_id_from_chars("elem_ent", 8)), element_type);
 	hook_new_type(res);
 	return res;
 }
@@ -1606,6 +1639,7 @@ void free_array_automatic_entities(ir_type *array) {
 }
 
 void free_array_entities (ir_type *array) {
+	(void) array;
 	assert(array && (array->type_op == type_array));
 }
 
@@ -1637,8 +1671,8 @@ set_array_bounds_int(ir_type *array, int dimension, int lower_bound, int upper_b
 	ir_graph *rem = current_ir_graph;
 	current_ir_graph = get_const_code_irg();
 	set_array_bounds(array, dimension,
-	          new_Const(mode_Iu, new_tarval_from_long (lower_bound, mode_Iu)),
-	          new_Const(mode_Iu, new_tarval_from_long (upper_bound, mode_Iu )));
+	          new_Const_long(mode_Iu, lower_bound),
+	          new_Const_long(mode_Iu, upper_bound));
 	current_ir_graph = rem;
 }
 
@@ -1653,7 +1687,7 @@ void set_array_lower_bound_int(ir_type *array, int dimension, int lower_bound) {
 	ir_graph *rem = current_ir_graph;
 	current_ir_graph = get_const_code_irg();
 	set_array_lower_bound(array, dimension,
-	     new_Const(mode_Iu, new_tarval_from_long (lower_bound, mode_Iu)));
+	     new_Const_long(mode_Iu, lower_bound));
 	current_ir_graph = rem;
 }
 void
@@ -1666,13 +1700,13 @@ void set_array_upper_bound_int(ir_type *array, int dimension, int upper_bound) {
 	ir_graph *rem = current_ir_graph;
 	current_ir_graph = get_const_code_irg();
 	set_array_upper_bound(array, dimension,
-	            new_Const(mode_Iu, new_tarval_from_long (upper_bound, mode_Iu)));
+	            new_Const_long(mode_Iu, upper_bound));
 	current_ir_graph = rem;
 }
 
 int has_array_lower_bound(const ir_type *array, int dimension) {
 	assert(array && (array->type_op == type_array));
-	return (get_irn_op(array->attr.aa.lower_bound[dimension]) != op_Unknown);
+	return !is_Unknown(array->attr.aa.lower_bound[dimension]);
 }
 
 ir_node *get_array_lower_bound(const ir_type *array, int dimension) {
@@ -1684,13 +1718,13 @@ long get_array_lower_bound_int(const ir_type *array, int dimension) {
 	ir_node *node;
 	assert(array && (array->type_op == type_array));
 	node = array->attr.aa.lower_bound[dimension];
-	assert(get_irn_op(node) == op_Const);
+	assert(is_Const(node));
 	return get_tarval_long(get_Const_tarval(node));
 }
 
 int has_array_upper_bound(const ir_type *array, int dimension) {
 	assert(array && (array->type_op == type_array));
-	return get_irn_op(array->attr.aa.upper_bound[dimension]) != op_Unknown;
+	return !is_Unknown(array->attr.aa.upper_bound[dimension]);
 }
 
 ir_node *get_array_upper_bound(const ir_type *array, int dimension) {
@@ -1702,7 +1736,7 @@ long get_array_upper_bound_int(const ir_type *array, int dimension) {
 	ir_node *node;
 	assert(array && (array->type_op == type_array));
 	node = array->attr.aa.upper_bound[dimension];
-	assert(get_irn_op(node) == op_Const);
+	assert(is_Const(node));
 	return get_tarval_long(get_Const_tarval(node));
 }
 
@@ -1756,7 +1790,7 @@ int (is_Array_type)(const ir_type *array) {
 	return _is_array_type(array);
 }
 
-void set_array_size_bits(ir_type *tp, int size) {
+void set_array_size(ir_type *tp, unsigned size) {
 	/* FIXME: Here we should make some checks with the element type size */
 	tp->size = size;
 }
@@ -1780,6 +1814,7 @@ ir_type *new_type_enumeration(ident *name, int n_enums) {
 }
 
 void free_enumeration_entities(ir_type *enumeration) {
+	(void) enumeration;
 	assert(enumeration && (enumeration->type_op == type_enumeration));
 }
 void free_enumeration_attrs(ir_type *enumeration) {
@@ -1839,9 +1874,9 @@ int (is_Enumeration_type)(const ir_type *enumeration) {
 void set_enumeration_mode(ir_type *tp, ir_mode *mode) {
 	assert(mode_is_int(mode) && "Modes of enumerations must be integers");
 	/* For pointer and enumeration size depends on the mode, but only byte size allowed. */
-	assert((get_mode_size_bits(mode) & 7) == 0 && "unorthodox modes not implemented");
+	assert((get_mode_size_bits(mode) % 8) == 0 && "unorthodox modes not implemented");
 
-	tp->size = get_mode_size_bits(mode);
+	tp->size = get_mode_size_bytes(mode);
 	tp->mode = mode;
 }
 
@@ -1856,8 +1891,8 @@ ir_type *new_d_type_pointer(ident *name, ir_type *points_to, ir_mode *ptr_mode,
 	assert(mode_is_reference(ptr_mode));
 	res = new_type(type_pointer, ptr_mode, name, db);
 	res->attr.pa.points_to = points_to;
-	assert((get_mode_size_bytes(res->mode) != -1) && "unorthodox modes not implemented");
-	res->size = get_mode_size_bits(res->mode);
+	assert((get_mode_size_bits(res->mode) % 8 == 0) && "unorthodox modes not implemented");
+	res->size = get_mode_size_bytes(res->mode);
 	res->flags |= tf_layout_fixed;
 	hook_new_type(res);
 	return res;
@@ -1868,10 +1903,12 @@ ir_type *new_type_pointer(ident *name, ir_type *points_to, ir_mode *ptr_mode) {
 }
 
 void free_pointer_entities(ir_type *pointer) {
+	(void) pointer;
 	assert(pointer && (pointer->type_op == type_pointer));
 }
 
 void free_pointer_attrs(ir_type *pointer) {
+	(void) pointer;
 	assert(pointer && (pointer->type_op == type_pointer));
 }
 
@@ -1896,7 +1933,7 @@ void set_pointer_mode(ir_type *tp, ir_mode *mode) {
 	/* For pointer and enumeration size depends on the mode, but only byte size allowed. */
 	assert((get_mode_size_bits(mode) & 7) == 0 && "unorthodox modes not implemented");
 
-	tp->size = get_mode_size_bits(mode);
+	tp->size = get_mode_size_bytes(mode);
 	tp->mode = mode;
 }
 
@@ -1921,8 +1958,9 @@ ir_type *find_pointer_type_to_type (ir_type *tp) {
 /* create a new type primitive */
 ir_type *new_d_type_primitive(ident *name, ir_mode *mode, dbg_info *db) {
 	ir_type *res = new_type(type_primitive, mode, name, db);
-	res->size  = get_mode_size_bits(mode);
+	res->size  = get_mode_size_bytes(mode);
 	res->flags |= tf_layout_fixed;
+	res->attr.ba.base_type = NULL;
 	hook_new_type(res);
 	return res;
 }
@@ -1931,7 +1969,7 @@ ir_type *new_type_primitive(ident *name, ir_mode *mode) {
 	return new_d_type_primitive(name, mode, NULL);
 }
 
-/* typecheck */
+/* type check */
 int (is_Primitive_type)(const ir_type *primitive) {
 	return _is_primitive_type(primitive);
 }
@@ -1941,10 +1979,21 @@ void set_primitive_mode(ir_type *tp, ir_mode *mode) {
 	assert(mode_is_data(mode));
 
 	/* For primitive size depends on the mode. */
-	tp->size = get_mode_size_bits(mode);
+	tp->size = get_mode_size_bytes(mode);
 	tp->mode = mode;
 }
 
+/* Return the base type of a primitive (bitfield) type or NULL if none. */
+ir_type *get_primitive_base_type(ir_type *tp) {
+	assert(is_Primitive_type(tp));
+	return tp->attr.ba.base_type;
+}
+
+/* Sets the base type of a primitive (bitfield) type. */
+void set_primitive_base_type(ir_type *tp, ir_type *base_tp) {
+	assert(is_Primitive_type(tp));
+	tp->attr.ba.base_type = base_tp;
+}
 
 /*-----------------------------------------------------------------*/
 /* common functionality                                            */
@@ -2003,6 +2052,11 @@ int is_compound_type(const ir_type *tp) {
 	return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
 }
 
+int is_code_type(const ir_type *tp) {
+	assert(tp && tp->kind == k_type);
+	return tp->type_op == tpop_code;
+}
+
 /* Checks, whether a type is a frame type */
 int is_frame_type(const ir_type *tp) {
 	return tp->flags & tf_frame_type;
@@ -2018,6 +2072,18 @@ int is_lowered_type(const ir_type *tp) {
 	return tp->flags & tf_lowered_type;
 }
 
+/* Makes a new value type. */
+ir_type *new_type_value(ident *name) {
+	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);
+
+	return res;
+}
+
 /* Makes a new frame type. */
 ir_type *new_type_frame(ident *name) {
 	ir_type *res = new_type_class(name);
@@ -2033,6 +2099,25 @@ ir_type *new_type_frame(ident *name) {
 	return res;
 }
 
+/* Makes a clone of a frame type. */
+ir_type *clone_frame_type(ir_type *type) {
+	ir_type *res;
+	int     i, n;
+
+	assert(is_frame_type(type));
+	/* the entity link resource should be allocated if this function is called */
+	assert(irp_resources_reserved(irp) & IR_RESOURCE_ENTITY_LINK);
+
+	res = new_type_frame(type->name);
+	for (i = 0, n = get_class_n_members(type); i < n; ++i) {
+		ir_entity *ent  = get_class_member(type, i);
+		ir_entity *nent = copy_entity_own(ent, res);
+		set_entity_link(ent, nent);
+		set_entity_link(nent, ent);
+	}
+	return res;
+}
+
 /* Sets a lowered type for a type. This sets both associations. */
 void set_lowered_type(ir_type *tp, ir_type *lowered_type) {
 	assert(is_type(tp) && is_type(lowered_type));
@@ -2050,7 +2135,7 @@ ir_type *get_associated_type(const ir_type *tp) {
 }
 
 /* set the type size for the unknown and none ir_type */
-void set_default_size_bits(ir_type *tp, int size) {
+void set_default_size(ir_type *tp, unsigned size) {
 	tp->size = size;
 }
 
@@ -2059,56 +2144,66 @@ void set_default_size_bits(ir_type *tp, int size) {
  * 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);
-  assert(get_type_alignment_bytes(frame_type) > 0);
-
-  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;
+ir_entity *frame_alloc_area(ir_type *frame_type, int size, unsigned alignment, int at_start) {
+	ir_entity *area;
+	ir_type *tp;
+	ident *name;
+	char buf[32];
+	unsigned frame_align;
+	int 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);
+	assert(get_type_alignment_bytes(frame_type) > 0);
+	set_type_state(frame_type, layout_undefined);
+
+	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 - 1);
+
+	tp = new_type_array(id_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;
+
+		/* increase size to match alignment... */
+		if (alignment > frame_align) {
+			frame_align = alignment;
+			set_type_alignment_bytes(frame_type, frame_align);
+			frame_size  = (frame_size + frame_align - 1) & ~(frame_align - 1);
+		}
+	} else {
+		/* calculate offset and new type size */
+		offset = (frame_size + alignment - 1) & ~(alignment - 1);
+		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);
+
+	set_type_state(frame_type, layout_fixed);
+	return area;
 }