X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=type.c;h=88219a441197435c5ac7395c3a9e34ce7a4b590b;hb=3def71f59901789159be20bfdc806fb0fb1b6375;hp=de4738dd0d3705566974afefe37d4c890ac80d44;hpb=1b580cf22ca849edc62afa24304ff0432954877a;p=cparser

diff --git a/type.c b/type.c
index de4738d..88219a4 100644
--- a/type.c
+++ b/type.c
@@ -33,14 +33,12 @@
 #include "warning.h"
 #include "diagnostic.h"
 #include "printer.h"
-#include "driver/firm_cmdline.h"
 
 /** The default calling convention. */
 cc_kind_t default_calling_convention = CC_CDECL;
 
-static struct obstack   _type_obst;
-struct obstack         *type_obst                 = &_type_obst;
-static bool             print_implicit_array_size = false;
+static struct obstack type_obst;
+static bool           print_implicit_array_size = false;
 
 static void intern_print_type_pre(const type_t *type);
 static void intern_print_type_post(const type_t *type);
@@ -52,6 +50,44 @@ struct atomic_type_properties_t {
 	unsigned   flags;             /**< type flags from atomic_type_flag_t */
 };
 
+/**
+ * Returns the size of a type node.
+ *
+ * @param kind  the type kind
+ */
+static size_t get_type_struct_size(type_kind_t kind)
+{
+	static const size_t sizes[] = {
+		[TYPE_ATOMIC]          = sizeof(atomic_type_t),
+		[TYPE_COMPLEX]         = sizeof(complex_type_t),
+		[TYPE_IMAGINARY]       = sizeof(imaginary_type_t),
+		[TYPE_BITFIELD]        = sizeof(bitfield_type_t),
+		[TYPE_COMPOUND_STRUCT] = sizeof(compound_type_t),
+		[TYPE_COMPOUND_UNION]  = sizeof(compound_type_t),
+		[TYPE_ENUM]            = sizeof(enum_type_t),
+		[TYPE_FUNCTION]        = sizeof(function_type_t),
+		[TYPE_POINTER]         = sizeof(pointer_type_t),
+		[TYPE_REFERENCE]       = sizeof(reference_type_t),
+		[TYPE_ARRAY]           = sizeof(array_type_t),
+		[TYPE_TYPEDEF]         = sizeof(typedef_type_t),
+		[TYPE_TYPEOF]          = sizeof(typeof_type_t),
+	};
+	assert(lengthof(sizes) == (int)TYPE_TYPEOF + 1);
+	assert(kind <= TYPE_TYPEOF);
+	assert(sizes[kind] != 0);
+	return sizes[kind];
+}
+
+type_t *allocate_type_zero(type_kind_t kind)
+{
+	size_t  const size = get_type_struct_size(kind);
+	type_t *const res  = obstack_alloc(&type_obst, size);
+	memset(res, 0, size);
+	res->base.kind = kind;
+
+	return res;
+}
+
 /**
  * Properties of atomic types.
  */
@@ -147,7 +183,7 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = {
 		              | ATOMIC_TYPE_FLAG_SIGNED,
 	},
 	[ATOMIC_TYPE_LONG_DOUBLE] = {
-		.size       = 12,
+		.size       = (unsigned) -1, /* will be filled in later */
 		.alignment  = (unsigned) -1,
 		.flags      = ATOMIC_TYPE_FLAG_FLOAT | ATOMIC_TYPE_FLAG_ARITHMETIC
 		              | ATOMIC_TYPE_FLAG_SIGNED,
@@ -155,9 +191,14 @@ static atomic_type_properties_t atomic_type_properties[ATOMIC_TYPE_LAST+1] = {
 	/* complex and imaginary types are set in init_types */
 };
 
+static inline bool is_po2(unsigned x)
+{
+	return (x & (x-1)) == 0;
+}
+
 void init_types(void)
 {
-	obstack_init(type_obst);
+	obstack_init(&type_obst);
 
 	atomic_type_properties_t *props = atomic_type_properties;
 
@@ -166,7 +207,8 @@ void init_types(void)
 	}
 
 	unsigned int_size   = machine_size < 32 ? 2 : 4;
-	unsigned long_size  = machine_size < 64 ? 4 : 8;
+	/* long is always 32bit on windows */
+	unsigned long_size  = c_mode & _MS ? 4 : (machine_size < 64 ? 4 : 8);
 	unsigned llong_size = machine_size < 32 ? 4 : 8;
 
 	props[ATOMIC_TYPE_INT].size            = int_size;
@@ -184,14 +226,27 @@ void init_types(void)
 
 	/* TODO: backend specific, need a way to query the backend for this.
 	 * The following are good settings for x86 */
-	props[ATOMIC_TYPE_FLOAT].alignment       = 4;
-	props[ATOMIC_TYPE_DOUBLE].alignment      = 4;
-	props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4;
-	props[ATOMIC_TYPE_LONGLONG].alignment    = 4;
-	props[ATOMIC_TYPE_ULONGLONG].alignment   = 4;
-	if (firm_opt.os_support == OS_SUPPORT_MACHO) {
-		props[ATOMIC_TYPE_LONG_DOUBLE].size      = 16;
-		props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 16;
+	if (machine_size <= 32) {
+		props[ATOMIC_TYPE_FLOAT].alignment       = 4;
+		props[ATOMIC_TYPE_DOUBLE].alignment      = 4;
+		props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 4;
+		props[ATOMIC_TYPE_LONGLONG].alignment    = 4;
+		props[ATOMIC_TYPE_ULONGLONG].alignment   = 4;
+	} else {
+		props[ATOMIC_TYPE_FLOAT].alignment       = 4;
+		props[ATOMIC_TYPE_DOUBLE].alignment      = 8;
+		props[ATOMIC_TYPE_LONG_DOUBLE].alignment = 8;
+		props[ATOMIC_TYPE_LONGLONG].alignment    = 8;
+		props[ATOMIC_TYPE_ULONGLONG].alignment   = 8;
+	}
+
+	if (long_double_size > 0) {
+		props[ATOMIC_TYPE_LONG_DOUBLE].size      = long_double_size;
+		if (is_po2(long_double_size)) {
+			props[ATOMIC_TYPE_LONG_DOUBLE].alignment = long_double_size;
+		}
+	} else {
+		props[ATOMIC_TYPE_LONG_DOUBLE] = props[ATOMIC_TYPE_DOUBLE];
 	}
 
 	/* TODO: make this configurable for platforms which do not use byte sized
@@ -203,20 +258,26 @@ void init_types(void)
 
 void exit_types(void)
 {
-	obstack_free(type_obst, NULL);
+	obstack_free(&type_obst, NULL);
 }
 
-void print_type_qualifiers(type_qualifiers_t qualifiers)
+void print_type_qualifiers(type_qualifiers_t const qualifiers, QualifierSeparators const q)
 {
+	size_t sep = q & QUAL_SEP_START ? 0 : 1;
 	if (qualifiers & TYPE_QUALIFIER_CONST) {
-		print_string("const ");
+		print_string(" const" + sep);
+		sep = 0;
 	}
 	if (qualifiers & TYPE_QUALIFIER_VOLATILE) {
-		print_string("volatile ");
+		print_string(" volatile" + sep);
+		sep = 0;
 	}
 	if (qualifiers & TYPE_QUALIFIER_RESTRICT) {
-		print_string("restrict ");
+		print_string(" restrict" + sep);
+		sep = 0;
 	}
+	if (sep == 0 && q & QUAL_SEP_END)
+		print_char(' ');
 }
 
 const char *get_atomic_kind_name(atomic_type_kind_t kind)
@@ -262,7 +323,7 @@ static void print_atomic_kinds(atomic_type_kind_t kind)
  */
 static void print_atomic_type(const atomic_type_t *type)
 {
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 	print_atomic_kinds(type->akind);
 }
 
@@ -273,7 +334,7 @@ static void print_atomic_type(const atomic_type_t *type)
  */
 static void print_complex_type(const complex_type_t *type)
 {
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 	print_string("_Complex");
 	print_atomic_kinds(type->akind);
 }
@@ -285,7 +346,7 @@ static void print_complex_type(const complex_type_t *type)
  */
 static void print_imaginary_type(const imaginary_type_t *type)
 {
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 	print_string("_Imaginary ");
 	print_atomic_kinds(type->akind);
 }
@@ -312,7 +373,7 @@ static void print_function_type_pre(const function_type_t *type)
 			break;
 	}
 
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 
 	intern_print_type_pre(type->return_type);
 
@@ -364,11 +425,11 @@ static void print_function_type_post(const function_type_t *type,
 			} else {
 				print_string(", ");
 			}
-			const type_t *const type = parameter->declaration.type;
-			if (type == NULL) {
+			const type_t *const param_type = parameter->declaration.type;
+			if (param_type == NULL) {
 				print_string(parameter->base.symbol->string);
 			} else {
-				print_type_ext(type, parameter->base.symbol, NULL);
+				print_type_ext(param_type, parameter->base.symbol, NULL);
 			}
 		}
 	}
@@ -406,10 +467,7 @@ static void print_pointer_type_pre(const pointer_type_t *type)
 		print_string(") ");
 	}
 	print_string("*");
-	type_qualifiers_t const qual = type->base.qualifiers;
-	if (qual != 0)
-		print_string(" ");
-	print_type_qualifiers(qual);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_START);
 }
 
 /**
@@ -473,7 +531,7 @@ static void print_array_type_post(const array_type_t *type)
 	if (type->is_static) {
 		print_string("static ");
 	}
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 	if (type->size_expression != NULL
 			&& (print_implicit_array_size || !type->has_implicit_size)) {
 		print_expression(type->size_expression);
@@ -536,7 +594,7 @@ void print_enum_definition(const enum_t *enume)
  */
 static void print_type_enum(const enum_type_t *type)
 {
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 	print_string("enum ");
 
 	enum_t   *enume  = type->enume;
@@ -581,7 +639,7 @@ void print_compound_definition(const compound_t *compound)
  */
 static void print_compound_type(const compound_type_t *type)
 {
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 
 	if (type->base.kind == TYPE_COMPOUND_STRUCT) {
 		print_string("struct ");
@@ -606,7 +664,7 @@ static void print_compound_type(const compound_type_t *type)
  */
 static void print_typedef_type_pre(const typedef_type_t *const type)
 {
-	print_type_qualifiers(type->base.qualifiers);
+	print_type_qualifiers(type->base.qualifiers, QUAL_SEP_END);
 	print_string(type->typedefe->base.symbol->string);
 }
 
@@ -656,9 +714,6 @@ static void intern_print_type_pre(const type_t *const type)
 	case TYPE_COMPOUND_UNION:
 		print_compound_type(&type->compound);
 		return;
-	case TYPE_BUILTIN:
-		print_string(type->builtin.symbol->string);
-		return;
 	case TYPE_FUNCTION:
 		print_function_type_pre(&type->function);
 		return;
@@ -715,7 +770,6 @@ static void intern_print_type_post(const type_t *const type)
 	case TYPE_ENUM:
 	case TYPE_COMPOUND_STRUCT:
 	case TYPE_COMPOUND_UNION:
-	case TYPE_BUILTIN:
 	case TYPE_TYPEOF:
 	case TYPE_TYPEDEF:
 		break;
@@ -735,11 +789,6 @@ void print_type(const type_t *const type)
 void print_type_ext(const type_t *const type, const symbol_t *symbol,
                     const scope_t *parameters)
 {
-	if (type == NULL) {
-		print_string("nil type");
-		return;
-	}
-
 	intern_print_type_pre(type);
 	if (symbol != NULL) {
 		print_string(" ");
@@ -752,34 +801,6 @@ void print_type_ext(const type_t *const type, const symbol_t *symbol,
 	}
 }
 
-/**
- * Return the size of a type AST node.
- *
- * @param type  The type.
- */
-static size_t get_type_struct_size(const type_t *type)
-{
-	switch(type->kind) {
-	case TYPE_ATOMIC:          return sizeof(atomic_type_t);
-	case TYPE_COMPLEX:         return sizeof(complex_type_t);
-	case TYPE_IMAGINARY:       return sizeof(imaginary_type_t);
-	case TYPE_COMPOUND_STRUCT:
-	case TYPE_COMPOUND_UNION:  return sizeof(compound_type_t);
-	case TYPE_ENUM:            return sizeof(enum_type_t);
-	case TYPE_FUNCTION:        return sizeof(function_type_t);
-	case TYPE_POINTER:         return sizeof(pointer_type_t);
-	case TYPE_REFERENCE:       return sizeof(reference_type_t);
-	case TYPE_ARRAY:           return sizeof(array_type_t);
-	case TYPE_BUILTIN:         return sizeof(builtin_type_t);
-	case TYPE_TYPEDEF:         return sizeof(typedef_type_t);
-	case TYPE_TYPEOF:          return sizeof(typeof_type_t);
-	case TYPE_BITFIELD:        return sizeof(bitfield_type_t);
-	case TYPE_ERROR:           panic("error type found");
-	case TYPE_INVALID:         panic("invalid type found");
-	}
-	panic("unknown type found");
-}
-
 /**
  * Duplicates a type.
  *
@@ -790,9 +811,9 @@ static size_t get_type_struct_size(const type_t *type)
  */
 type_t *duplicate_type(const type_t *type)
 {
-	size_t size = get_type_struct_size(type);
+	size_t size = get_type_struct_size(type->kind);
 
-	type_t *copy = obstack_alloc(type_obst, size);
+	type_t *const copy = obstack_alloc(&type_obst, size);
 	memcpy(copy, type, size);
 	copy->base.firm_type = NULL;
 
@@ -834,7 +855,7 @@ type_t *get_qualified_type(type_t *orig_type, type_qualifiers_t const qual)
 		copy                     = duplicate_type(type);
 		copy->array.element_type = qual_element_type;
 	} else if (is_type_valid(type)) {
-		if ((type->base.qualifiers & qual) == qual)
+		if ((type->base.qualifiers & qual) == (int)qual)
 			return orig_type;
 
 		copy                   = duplicate_type(type);
@@ -998,11 +1019,8 @@ bool is_type_scalar(const type_t *type)
 {
 	assert(!is_typeref(type));
 
-	switch (type->kind) {
-		case TYPE_POINTER: return true;
-		case TYPE_BUILTIN: return is_type_scalar(type->builtin.real_type);
-		default:           break;
-	}
+	if (type->kind == TYPE_POINTER)
+		return true;
 
 	return is_type_arithmetic(type);
 }
@@ -1043,7 +1061,6 @@ bool is_type_incomplete(const type_t *type)
 	case TYPE_FUNCTION:
 	case TYPE_POINTER:
 	case TYPE_REFERENCE:
-	case TYPE_BUILTIN:
 	case TYPE_ERROR:
 		return false;
 
@@ -1062,14 +1079,6 @@ bool is_type_object(const type_t *type)
 	return !is_type_function(type) && !is_type_incomplete(type);
 }
 
-bool is_builtin_va_list(type_t *type)
-{
-	type_t *tp = skip_typeref(type);
-
-	return tp->kind == type_valist->kind &&
-	       tp->builtin.symbol == type_valist->builtin.symbol;
-}
-
 /**
  * Check if two function types are compatible.
  */
@@ -1193,7 +1202,6 @@ bool types_compatible(const type_t *type1, const type_t *type2)
 		break;
 	}
 	case TYPE_ENUM:
-	case TYPE_BUILTIN:
 		/* TODO: not implemented */
 		break;
 
@@ -1302,8 +1310,6 @@ unsigned get_type_size(type_t *type)
 	}
 	case TYPE_BITFIELD:
 		return 0;
-	case TYPE_BUILTIN:
-		return get_type_size(type->builtin.real_type);
 	case TYPE_TYPEDEF:
 		return get_type_size(type->typedeft.typedefe->type);
 	case TYPE_TYPEOF:
@@ -1348,8 +1354,6 @@ unsigned get_type_alignment(type_t *type)
 		return get_type_alignment(type->array.element_type);
 	case TYPE_BITFIELD:
 		return 0;
-	case TYPE_BUILTIN:
-		return get_type_alignment(type->builtin.real_type);
 	case TYPE_TYPEDEF: {
 		il_alignment_t alignment
 			= get_type_alignment(type->typedeft.typedefe->type);
@@ -1388,8 +1392,6 @@ decl_modifiers_t get_type_modifiers(const type_t *type)
 	case TYPE_BITFIELD:
 	case TYPE_ARRAY:
 		return 0;
-	case TYPE_BUILTIN:
-		return get_type_modifiers(type->builtin.real_type);
 	case TYPE_TYPEDEF: {
 		decl_modifiers_t modifiers = type->typedeft.typedefe->modifiers;
 		modifiers |= get_type_modifiers(type->typedeft.typedefe->type);
@@ -1540,7 +1542,7 @@ type_t *identify_new_type(type_t *type)
 {
 	type_t *result = typehash_insert(type);
 	if (result != type) {
-		obstack_free(type_obst, type);
+		obstack_free(&type_obst, type);
 	}
 	return result;
 }
@@ -1553,10 +1555,7 @@ type_t *identify_new_type(type_t *type)
  */
 type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(atomic_type_t));
-	memset(type, 0, sizeof(atomic_type_t));
-
-	type->kind            = TYPE_ATOMIC;
+	type_t *const type = allocate_type_zero(TYPE_ATOMIC);
 	type->base.qualifiers = qualifiers;
 	type->atomic.akind    = akind;
 
@@ -1571,10 +1570,7 @@ type_t *make_atomic_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
  */
 type_t *make_complex_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(complex_type_t));
-	memset(type, 0, sizeof(complex_type_t));
-
-	type->kind            = TYPE_COMPLEX;
+	type_t *const type = allocate_type_zero(TYPE_COMPLEX);
 	type->base.qualifiers = qualifiers;
 	type->complex.akind   = akind;
 
@@ -1589,10 +1585,7 @@ type_t *make_complex_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers
  */
 type_t *make_imaginary_type(atomic_type_kind_t akind, type_qualifiers_t qualifiers)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(imaginary_type_t));
-	memset(type, 0, sizeof(imaginary_type_t));
-
-	type->kind            = TYPE_IMAGINARY;
+	type_t *const type = allocate_type_zero(TYPE_IMAGINARY);
 	type->base.qualifiers = qualifiers;
 	type->imaginary.akind = akind;
 
@@ -1607,10 +1600,7 @@ type_t *make_imaginary_type(atomic_type_kind_t akind, type_qualifiers_t qualifie
  */
 type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t));
-	memset(type, 0, sizeof(pointer_type_t));
-
-	type->kind                  = TYPE_POINTER;
+	type_t *const type = allocate_type_zero(TYPE_POINTER);
 	type->base.qualifiers       = qualifiers;
 	type->pointer.points_to     = points_to;
 	type->pointer.base_variable = NULL;
@@ -1625,11 +1615,8 @@ type_t *make_pointer_type(type_t *points_to, type_qualifiers_t qualifiers)
  */
 type_t *make_reference_type(type_t *refers_to)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(reference_type_t));
-	memset(type, 0, sizeof(reference_type_t));
-
-	type->kind                = TYPE_REFERENCE;
-	type->base.qualifiers     = 0;
+	type_t *const type = allocate_type_zero(TYPE_REFERENCE);
+	type->base.qualifiers     = TYPE_QUALIFIER_NONE;
 	type->reference.refers_to = refers_to;
 
 	return identify_new_type(type);
@@ -1645,10 +1632,7 @@ type_t *make_reference_type(type_t *refers_to)
 type_t *make_based_pointer_type(type_t *points_to,
 								type_qualifiers_t qualifiers, variable_t *variable)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(pointer_type_t));
-	memset(type, 0, sizeof(pointer_type_t));
-
-	type->kind                  = TYPE_POINTER;
+	type_t *const type = allocate_type_zero(TYPE_POINTER);
 	type->base.qualifiers       = qualifiers;
 	type->pointer.points_to     = points_to;
 	type->pointer.base_variable = variable;
@@ -1660,10 +1644,7 @@ type_t *make_based_pointer_type(type_t *points_to,
 type_t *make_array_type(type_t *element_type, size_t size,
                         type_qualifiers_t qualifiers)
 {
-	type_t *type = obstack_alloc(type_obst, sizeof(array_type_t));
-	memset(type, 0, sizeof(array_type_t));
-
-	type->kind                = TYPE_ARRAY;
+	type_t *const type = allocate_type_zero(TYPE_ARRAY);
 	type->base.qualifiers     = qualifiers;
 	type->array.element_type  = element_type;
 	type->array.size          = size;
@@ -1683,7 +1664,7 @@ static entity_t *pack_bitfield_members(il_size_t *struct_offset,
 	entity_t *member;
 	for (member = first; member != NULL; member = member->base.next) {
 		if (member->kind != ENTITY_COMPOUND_MEMBER)
-			break;
+			continue;
 
 		type_t *type = member->declaration.type;
 		if (type->kind != TYPE_BITFIELD)
@@ -1708,8 +1689,14 @@ static entity_t *pack_bitfield_members(il_size_t *struct_offset,
 			}
 		}
 
-		member->compound_member.offset     = offset;
-		member->compound_member.bit_offset = bit_offset;
+		if (byte_order_big_endian) {
+			size_t base_size = get_type_size(base_type) * BITS_PER_BYTE;
+			member->compound_member.offset     = offset & ~alignment_mask;
+			member->compound_member.bit_offset = base_size - bit_offset - bit_size;
+		} else {
+			member->compound_member.offset     = offset;
+			member->compound_member.bit_offset = bit_offset;
+		}
 
 		bit_offset += bit_size;
 		offset     += bit_offset / BITS_PER_BYTE;
@@ -1721,14 +1708,9 @@ static entity_t *pack_bitfield_members(il_size_t *struct_offset,
 
 	*struct_offset    = offset;
 	*struct_alignment = alignment;
-
 	return member;
 }
 
-/**
- * Finish the construction of a struct type by calculating its size, offsets,
- * alignment.
- */
 void layout_struct_type(compound_type_t *type)
 {
 	assert(type->compound != NULL);
@@ -1790,14 +1772,11 @@ void layout_struct_type(compound_type_t *type)
 		}
 	}
 
+	source_position_t const *const pos = &compound->base.source_position;
 	if (need_pad) {
-		if (warning.padded) {
-			warningf(&compound->base.source_position, "'%T' needs padding",
-			         type);
-		}
-	} else if (compound->packed && warning.packed) {
-		warningf(&compound->base.source_position,
-		         "superfluous packed attribute on '%T'", type);
+		warningf(WARN_PADDED, pos, "'%T' needs padding", type);
+	} else if (compound->packed) {
+		warningf(WARN_PACKED, pos, "superfluous packed attribute on '%T'", type);
 	}
 
 	compound->size      = offset;
@@ -1805,10 +1784,6 @@ void layout_struct_type(compound_type_t *type)
 	compound->layouted  = true;
 }
 
-/**
- * Finish the construction of an union type by calculating
- * its size and alignment.
- */
 void layout_union_type(compound_type_t *type)
 {
 	assert(type->compound != NULL);
@@ -1843,6 +1818,84 @@ void layout_union_type(compound_type_t *type)
 	compound->alignment = alignment;
 }
 
+function_parameter_t *allocate_parameter(type_t *const type)
+{
+	function_parameter_t *const param = obstack_alloc(&type_obst, sizeof(*param));
+	memset(param, 0, sizeof(*param));
+	param->type = type;
+	return param;
+}
+
+type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
+                             type_t *argument_type2)
+{
+	function_parameter_t *const parameter2 = allocate_parameter(argument_type2);
+	function_parameter_t *const parameter1 = allocate_parameter(argument_type1);
+	parameter1->next = parameter2;
+
+	type_t *type               = allocate_type_zero(TYPE_FUNCTION);
+	type->function.return_type = return_type;
+	type->function.parameters  = parameter1;
+	type->function.linkage     = LINKAGE_C;
+
+	return identify_new_type(type);
+}
+
+type_t *make_function_1_type(type_t *return_type, type_t *argument_type)
+{
+	function_parameter_t *const parameter = allocate_parameter(argument_type);
+
+	type_t *type               = allocate_type_zero(TYPE_FUNCTION);
+	type->function.return_type = return_type;
+	type->function.parameters  = parameter;
+	type->function.linkage     = LINKAGE_C;
+
+	return identify_new_type(type);
+}
+
+type_t *make_function_1_type_variadic(type_t *return_type,
+                                      type_t *argument_type)
+{
+	function_parameter_t *const parameter = allocate_parameter(argument_type);
+
+	type_t *type               = allocate_type_zero(TYPE_FUNCTION);
+	type->function.return_type = return_type;
+	type->function.parameters  = parameter;
+	type->function.variadic    = true;
+	type->function.linkage     = LINKAGE_C;
+
+	return identify_new_type(type);
+}
+
+type_t *make_function_0_type(type_t *return_type)
+{
+	type_t *type               = allocate_type_zero(TYPE_FUNCTION);
+	type->function.return_type = return_type;
+	type->function.parameters  = NULL;
+	type->function.linkage     = LINKAGE_C;
+
+	return identify_new_type(type);
+}
+
+type_t *make_function_type(type_t *return_type, int n_types,
+                           type_t *const *argument_types,
+						   decl_modifiers_t modifiers)
+{
+	type_t *type               = allocate_type_zero(TYPE_FUNCTION);
+	type->function.return_type = return_type;
+	type->function.modifiers  |= modifiers;
+	type->function.linkage     = LINKAGE_C;
+
+	function_parameter_t **anchor = &type->function.parameters;
+	for (int i = 0; i < n_types; ++i) {
+		function_parameter_t *parameter = allocate_parameter(argument_types[i]);
+		*anchor = parameter;
+		anchor  = &parameter->next;
+	}
+
+	return identify_new_type(type);
+}
+
 /**
  * Debug helper. Prints the given type to stdout.
  */