X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=695b4cb264629d3736c761f80ee30667b33b7429;hb=0709f476ea7bc26f606aacfda4675c44fbba4fc4;hp=8d1051df27f4e10fcbfd7715dca5c55d004f2a64;hpb=87f6a720c6ccb67fa8ce2946847e62c0e4e8aa08;p=cparser

diff --git a/ast2firm.c b/ast2firm.c
index 8d1051d..695b4cb 100644
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -59,6 +59,7 @@ static ir_node **imature_blocks;
 
 static const declaration_t *current_function_decl;
 static ir_node             *current_function_name;
+static ir_node             *current_funcsig;
 
 static struct obstack asm_obst;
 
@@ -81,7 +82,7 @@ ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos)
 {
 	const declaration_t *declaration = get_irg_loc_description(irg, pos);
 
-	warningf(declaration->source_position,
+	warningf(&declaration->source_position,
 	         "variable '%#T' might be used uninitialized",
 	         declaration->type, declaration->symbol);
 	return new_r_Unknown(irg, mode);
@@ -122,196 +123,79 @@ static ident *unique_ident(const char *tag)
 	return new_id_from_str(buf);
 }
 
-/**
- * Return the signed integer mode of size bytes.
- *
- * @param size   the size
- */
-static ir_mode *get_smode(unsigned size)
-{
-	static ir_mode *s_modes[16 + 1] = {0, };
-	ir_mode *res;
+static ir_mode *_atomic_modes[ATOMIC_TYPE_LAST+1];
 
-	if (size <= 0 || size > 16)
-		return NULL;
-
-	res = s_modes[size];
-	if (res == NULL) {
-		unsigned bits;
-    	char name[32];
+static ir_mode *mode_int, *mode_uint;
 
-    	bits = size * 8;
-    	snprintf(name, sizeof(name), "i%u", bits);
-    	res = new_ir_mode(name, irms_int_number, bits, 1, irma_twos_complement,
-    					bits <= machine_size ? machine_size : bits );
+static ir_node *expression_to_firm(const expression_t *expression);
+static inline ir_mode *get_ir_mode(type_t *type);
 
-		s_modes[size] = res;
+static ir_mode *init_atomic_ir_mode(atomic_type_kind_t kind)
+{
+	unsigned flags = get_atomic_type_flags(kind);
+	unsigned size  = get_atomic_type_size(kind);
+	if( (flags & (ATOMIC_TYPE_FLAG_INTEGER | ATOMIC_TYPE_FLAG_FLOAT))
+			&& !(flags & ATOMIC_TYPE_FLAG_COMPLEX)) {
+		char            name[64];
+		mode_sort       sort;
+		unsigned        bit_size     = size * 8;
+		bool            is_signed    = (flags & ATOMIC_TYPE_FLAG_SIGNED) != 0;
+		mode_arithmetic arithmetic;
+		unsigned        modulo_shift;
+
+		if(flags & ATOMIC_TYPE_FLAG_INTEGER) {
+			assert(! (flags & ATOMIC_TYPE_FLAG_FLOAT));
+			snprintf(name, sizeof(name), "i%s%d", is_signed?"":"u", bit_size);
+			sort         = irms_int_number;
+			arithmetic   = irma_twos_complement;
+			modulo_shift = bit_size < machine_size ? machine_size : bit_size;
+		} else {
+			assert(flags & ATOMIC_TYPE_FLAG_FLOAT);
+			snprintf(name, sizeof(name), "f%d", bit_size);
+			sort         = irms_float_number;
+			arithmetic   = irma_ieee754;
+			modulo_shift = 0;
+		}
+		return new_ir_mode(name, sort, bit_size, is_signed, arithmetic,
+		                   modulo_shift);
 	}
-	return res;
-}
-
-/**
- * Return the unsigned integer mode of size bytes.
- *
- * @param size  the size
- */
-static ir_mode *get_umode(unsigned size)
-{
-	static ir_mode *u_modes[16 + 1] = {0, };
-	ir_mode *res;
-
-	if (size <= 0 || size > 16)
-		return NULL;
 
-	res = u_modes[size];
-	if (res == NULL) {
-		unsigned bits;
-		char name[32];
-
-		bits = size * 8;
-		snprintf(name, sizeof(name), "u%u", bits);
-		res = new_ir_mode(name, irms_int_number, bits, 0, irma_twos_complement,
-						bits <= machine_size ? machine_size : bits );
-
-		u_modes[size] = res;
-	}
-	return res;
+	return NULL;
 }
 
 /**
- * Return the pointer mode of size bytes.
- *
- * @param size  the size
+ * Initialises the atomic modes depending on the machine size.
  */
-static ir_mode *get_ptrmode(unsigned size, char *name)
+static void init_atomic_modes(void)
 {
-	static ir_mode *p_modes[16 + 1] = {0, };
-	ir_mode *res;
-
-	if (size <= 0 || size > 16)
-		return NULL;
-
-	res = p_modes[size];
-	if (res == NULL) {
-		unsigned bits;
-		char buf[32];
-
-		bits = size * 8;
-		if (name == NULL) {
-			snprintf(buf, sizeof(buf), "p%u", bits);
-			name = buf;
-		}
-		res = new_ir_mode(name, irms_reference, bits, 0, irma_twos_complement,
-						bits <= machine_size ? machine_size : bits);
-
-		p_modes[size] = res;
-
-		set_reference_mode_signed_eq(res, get_smode(size));
-		set_reference_mode_unsigned_eq(res, get_umode(size));
+	for(int i = 0; i <= ATOMIC_TYPE_LAST; ++i) {
+		_atomic_modes[i] = init_atomic_ir_mode((atomic_type_kind_t) i);
 	}
-	return res;
-}
-
-static ir_mode *_atomic_modes[ATOMIC_TYPE_LAST];
-
-static ir_mode *mode_int, *mode_uint;
-
-static ir_node *expression_to_firm(const expression_t *expression);
-static inline ir_mode *get_ir_mode(type_t *type);
-
-/**
- * Initialises the atomic modes depending on the machine size.
- */
-static void init_atomic_modes(void) {
-	unsigned int_size   = machine_size < 32 ? 2 : 4;
-	unsigned long_size  = machine_size < 64 ? 4 : 8;
-	unsigned llong_size = machine_size < 32 ? 4 : 8;
-
-	/* firm has no real void... */
-	_atomic_modes[ATOMIC_TYPE_VOID]        = mode_T;
-	_atomic_modes[ATOMIC_TYPE_CHAR]        = char_is_signed ? get_smode(1) : get_umode(1);
-	_atomic_modes[ATOMIC_TYPE_SCHAR]       = get_smode(1);
-	_atomic_modes[ATOMIC_TYPE_UCHAR]       = get_umode(1);
-	_atomic_modes[ATOMIC_TYPE_SHORT]       = get_smode(2);
-	_atomic_modes[ATOMIC_TYPE_USHORT]      = get_umode(2);
-	_atomic_modes[ATOMIC_TYPE_INT]         = get_smode(int_size);
-	_atomic_modes[ATOMIC_TYPE_UINT]        = get_umode(int_size);
-	_atomic_modes[ATOMIC_TYPE_LONG]        = get_smode(long_size);
-	_atomic_modes[ATOMIC_TYPE_ULONG]       = get_umode(long_size);
-	_atomic_modes[ATOMIC_TYPE_LONGLONG]    = get_smode(llong_size);
-	_atomic_modes[ATOMIC_TYPE_ULONGLONG]   = get_umode(llong_size);
-	_atomic_modes[ATOMIC_TYPE_FLOAT]       = mode_F;
-	_atomic_modes[ATOMIC_TYPE_DOUBLE]      = mode_D;
-	_atomic_modes[ATOMIC_TYPE_LONG_DOUBLE] = mode_E;
-	_atomic_modes[ATOMIC_TYPE_BOOL]        = get_umode(int_size);
-
-#ifdef PROVIDE_COMPLEX
-	_atomic_modes[ATOMIC_TYPE_BOOL]                  = _atomic_modes[ATOMIC_TYPE_INT];
-	_atomic_modes[ATOMIC_TYPE_FLOAT_IMAGINARY]       = _atomic_modes[ATOMIC_TYPE_FLOAT];
-	_atomic_modes[ATOMIC_TYPE_DOUBLE_IMAGINARY]      = _atomic_modes[ATOMIC_TYPE_DOUBLE];
-	_atomic_modes[ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY] = _atomic_modes[ATOMIC_TYPE_LONG_DOUBLE];
-#endif
-
-	/* Hmm, pointers should be machine size */
-	set_modeP_data(get_ptrmode(machine_size >> 3, NULL));
-	set_modeP_code(get_ptrmode(machine_size >> 3, NULL));
-
 	mode_int  = _atomic_modes[ATOMIC_TYPE_INT];
 	mode_uint = _atomic_modes[ATOMIC_TYPE_UINT];
-}
-
-static ir_mode *get_atomic_mode(const atomic_type_t* atomic_type)
-{
-	ir_mode *res = NULL;
-	if ((unsigned)atomic_type->akind < (unsigned)ATOMIC_TYPE_LAST)
-		res = _atomic_modes[(unsigned)atomic_type->akind];
-	if (res == NULL)
-		panic("Encountered unknown atomic type");
-	return res;
-}
-
-static unsigned get_atomic_type_size(const atomic_type_t *type)
-{
-	switch(type->akind) {
-	case ATOMIC_TYPE_CHAR:
-	case ATOMIC_TYPE_SCHAR:
-	case ATOMIC_TYPE_UCHAR:
-		return 1;
-
-	case ATOMIC_TYPE_SHORT:
-	case ATOMIC_TYPE_USHORT:
-		return 2;
-
-	case ATOMIC_TYPE_BOOL:
-	case ATOMIC_TYPE_INT:
-	case ATOMIC_TYPE_UINT:
-		return machine_size >> 3;
-
-	case ATOMIC_TYPE_LONG:
-	case ATOMIC_TYPE_ULONG:
-		return machine_size > 16 ? machine_size >> 3 : 4;
 
-	case ATOMIC_TYPE_LONGLONG:
-	case ATOMIC_TYPE_ULONGLONG:
-		return machine_size > 16 ? 8 : 4;
+	/* there's no real void type in firm */
+	_atomic_modes[ATOMIC_TYPE_VOID] = mode_int;
 
-	case ATOMIC_TYPE_FLOAT:
-		return 4;
+	/* initialize pointer modes */
+	char            name[64];
+	mode_sort       sort         = irms_reference;
+	unsigned        bit_size     = machine_size;
+	bool            is_signed    = 0;
+	mode_arithmetic arithmetic   = irma_twos_complement;
+	unsigned        modulo_shift
+		= bit_size < machine_size ? machine_size : bit_size;
 
-	case ATOMIC_TYPE_DOUBLE:
-		return 8;
+	snprintf(name, sizeof(name), "p%d", machine_size);
+	ir_mode *ptr_mode = new_ir_mode(name, sort, bit_size, is_signed, arithmetic,
+	                                modulo_shift);
 
-	case ATOMIC_TYPE_LONG_DOUBLE:
-		return 12;
+	set_reference_mode_signed_eq(ptr_mode, _atomic_modes[get_intptr_kind()]);
+	set_reference_mode_unsigned_eq(ptr_mode, _atomic_modes[get_uintptr_kind()]);
 
-	case ATOMIC_TYPE_VOID:
-		return 1;
-
-	case ATOMIC_TYPE_INVALID:
-	case ATOMIC_TYPE_LAST:
-		break;
-	}
-	panic("Trying to determine size of invalid atomic type");
+	/* Hmm, pointers should be machine size */
+	set_modeP_data(ptr_mode);
+	set_modeP_code(ptr_mode);
 }
 
 static unsigned get_compound_type_size(compound_type_t *type)
@@ -336,7 +220,7 @@ static unsigned get_type_size_const(type_t *type)
 	case TYPE_ERROR:
 		panic("error type occured");
 	case TYPE_ATOMIC:
-		return get_atomic_type_size(&type->atomic);
+		return get_atomic_type_size(type->atomic.akind);
 	case TYPE_ENUM:
 		return get_mode_size_bytes(mode_int);
 	case TYPE_COMPOUND_UNION:
@@ -397,22 +281,19 @@ static unsigned count_parameters(const function_type_t *function_type)
 	return count;
 }
 
-
 static ir_type *create_atomic_type(const atomic_type_t *type)
 {
-	dbg_info *dbgi  = get_dbg_info(&type->type.source_position);
-	ir_mode *mode   = get_atomic_mode(type);
-	ident   *id     = get_mode_ident(mode);
-	ir_type *irtype = new_d_type_primitive(id, mode, dbgi);
+	dbg_info           *dbgi      = get_dbg_info(&type->base.source_position);
+	atomic_type_kind_t  kind      = type->akind;
+	ir_mode            *mode      = _atomic_modes[kind];
+	unsigned            alignment = get_atomic_type_alignment(kind);
+	ident              *id        = get_mode_ident(mode);
+	ir_type            *irtype    = new_d_type_primitive(id, mode, dbgi);
 
-	/* TODO: this is x86 specific, we should fiddle this into
-	 * lang_features.h somehow... */
-	if(type->akind == ATOMIC_TYPE_LONG_DOUBLE
-			|| type->akind == ATOMIC_TYPE_DOUBLE
-			|| type->akind == ATOMIC_TYPE_LONGLONG
-			|| type->akind == ATOMIC_TYPE_ULONGLONG) {
-		set_type_alignment_bytes(irtype, 4);
-	}
+	if(type->base.alignment > alignment)
+		alignment = type->base.alignment;
+
+	set_type_alignment_bytes(irtype, alignment);
 
 	return irtype;
 }
@@ -424,7 +305,7 @@ static ir_type *create_method_type(const function_type_t *function_type)
 	ident   *id           = unique_ident("functiontype");
 	int      n_parameters = count_parameters(function_type);
 	int      n_results    = return_type == type_void ? 0 : 1;
-	dbg_info *dbgi        = get_dbg_info(&function_type->type.source_position);
+	dbg_info *dbgi        = get_dbg_info(&function_type->base.source_position);
 	ir_type *irtype       = new_d_type_method(id, n_parameters, n_results, dbgi);
 
 	if(return_type != type_void) {
@@ -455,10 +336,10 @@ static ir_type *create_pointer_type(pointer_type_t *type)
 	 * again (might be a struct). We therefore first create a void* pointer
 	 * and then set the real points_to type
 	 */
-	dbg_info *dbgi   = get_dbg_info(&type->type.source_position);
-	ir_type *ir_type = new_d_type_pointer(unique_ident("pointer"),
+	dbg_info *dbgi    = get_dbg_info(&type->base.source_position);
+	ir_type  *ir_type = new_d_type_pointer(unique_ident("pointer"),
 	                                    ir_type_void, mode_P_data, dbgi);
-	type->type.firm_type  = ir_type;
+	type->base.firm_type  = ir_type;
 
 	ir_points_to = get_ir_type(points_to);
 	set_pointer_points_to_type(ir_type, ir_points_to);
@@ -472,7 +353,7 @@ static ir_type *create_array_type(array_type_t *type)
 	ir_type *ir_element_type = get_ir_type(element_type);
 
 	ident    *id      = unique_ident("array");
-	dbg_info *dbgi    = get_dbg_info(&type->type.source_position);
+	dbg_info *dbgi    = get_dbg_info(&type->base.source_position);
 	ir_type  *ir_type = new_d_type_array(id, 1, ir_element_type, dbgi);
 
 	const int align = get_type_alignment_bytes(ir_element_type);
@@ -569,7 +450,7 @@ static ir_type *get_unsigned_int_type_for_bit_size(ir_type *base_tp,
 
 static ir_type *create_bitfield_type(bitfield_type_t *const type)
 {
-	type_t *base = skip_typeref(type->base);
+	type_t *base = skip_typeref(type->base_type);
 	assert(base->kind == TYPE_ATOMIC);
 	ir_type *irbase = get_ir_type(base);
 
@@ -607,12 +488,12 @@ static ir_type *create_struct_type(compound_type_t *type, ir_type *irtype,
 		} else {
 			id = unique_ident("__anonymous_struct");
 		}
-		dbg_info *dbgi  = get_dbg_info(&type->type.source_position);
+		dbg_info *dbgi  = get_dbg_info(&type->base.source_position);
 
 		irtype = new_d_type_struct(id, dbgi);
 
 		declaration->v.irtype = irtype;
-		type->type.firm_type  = irtype;
+		type->base.firm_type  = irtype;
 	} else {
 		offset    = *outer_offset;
 		align_all = *outer_align;
@@ -646,7 +527,7 @@ static ir_type *create_struct_type(compound_type_t *type, ir_type *irtype,
 
 		ir_type *base_irtype;
 		if(entry_type->kind == TYPE_BITFIELD) {
-			base_irtype = get_ir_type(entry_type->bitfield.base);
+			base_irtype = get_ir_type(entry_type->bitfield.base_type);
 		} else {
 			base_irtype = get_ir_type(entry_type);
 		}
@@ -742,18 +623,18 @@ static ir_type *create_union_type(compound_type_t *type, ir_type *irtype,
 		} else {
 			id = unique_ident("__anonymous_union");
 		}
-		dbg_info *dbgi = get_dbg_info(&type->type.source_position);
+		dbg_info *dbgi = get_dbg_info(&type->base.source_position);
 
 		irtype = new_d_type_union(id, dbgi);
 
 		declaration->v.irtype = irtype;
-		type->type.firm_type  = irtype;
+		type->base.firm_type  = irtype;
 	} else {
 		offset    = *outer_offset;
 		align_all = *outer_align;
 	}
 
-	type->type.firm_type = irtype;
+	type->base.firm_type = irtype;
 
 	declaration_t *entry = declaration->scope.declarations;
 	for( ; entry != NULL; entry = entry->next) {
@@ -836,7 +717,7 @@ static ir_type *create_union_type(compound_type_t *type, ir_type *irtype,
 
 static ir_type *create_enum_type(enum_type_t *const type)
 {
-	type->type.firm_type = ir_type_int;
+	type->base.firm_type = ir_type_int;
 
 	ir_mode *const mode    = mode_int;
 	tarval  *const one     = get_mode_one(mode);
@@ -1214,12 +1095,13 @@ static ir_node *wide_string_literal_to_firm(
 	return create_symconst(dbgi, mode_P_data, entity);
 }
 
-static ir_node *deref_address(ir_type *const irtype, ir_node *const addr,
+static ir_node *deref_address(type_t *const type, ir_node *const addr,
                               dbg_info *const dbgi)
 {
-	if (is_compound_type(irtype) ||
-			is_Method_type(irtype)   ||
-			is_Array_type(irtype)) {
+	ir_type *irtype = get_ir_type(type);
+	if (is_compound_type(irtype)
+			|| is_Method_type(irtype)
+			|| is_Array_type(irtype)) {
 		return addr;
 	}
 
@@ -1228,6 +1110,11 @@ static ir_node *deref_address(ir_type *const irtype, ir_node *const addr,
 	ir_node *const load     = new_d_Load(dbgi, memory, addr, mode);
 	ir_node *const load_mem = new_d_Proj(dbgi, load, mode_M, pn_Load_M);
 	ir_node *const load_res = new_d_Proj(dbgi, load, mode,   pn_Load_res);
+
+	if(type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) {
+		set_Load_volatility(load, volatility_is_volatile);
+	}
+
 	set_store(load_mem);
 	return load_res;
 }
@@ -1315,16 +1202,14 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
 	}
 	case DECLARATION_KIND_GLOBAL_VARIABLE: {
 		ir_node *const addr   = get_global_var_address(dbgi, declaration);
-		ir_type *const irtype = get_entity_type(declaration->v.entity);
-		return deref_address(irtype, addr, dbgi);
+		return deref_address(declaration->type, addr, dbgi);
 	}
 
 	case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: {
 		ir_entity *entity = declaration->v.entity;
 		ir_node   *frame  = get_local_frame(entity);
 		ir_node   *sel    = new_d_simpleSel(dbgi, new_NoMem(), frame, entity);
-		ir_type   *irtype = get_entity_type(entity);
-		return deref_address(irtype, sel, dbgi);
+		return deref_address(declaration->type, sel, dbgi);
 	}
 
 	case DECLARATION_KIND_VARIABLE_LENGTH_ARRAY:
@@ -1534,6 +1419,8 @@ static void assign_value(dbg_info *dbgi, ir_node *addr, type_t *type,
 	if(is_type_scalar(type)) {
 		ir_node  *store     = new_d_Store(dbgi, memory, addr, value);
 		ir_node  *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M);
+		if(type->base.qualifiers & TYPE_QUALIFIER_VOLATILE)
+			set_Store_volatility(store, volatility_is_volatile);
 		set_store(store_mem);
 	} else {
 		ir_type *irtype    = get_ir_type(type);
@@ -1571,7 +1458,7 @@ static void bitfield_store_to_firm(const unary_expression_t *expression,
 	assert(select->kind == EXPR_SELECT);
 	type_t       *type   = select->base.type;
 	assert(type->kind == TYPE_BITFIELD);
-	ir_mode      *mode   = get_ir_mode(type->bitfield.base);
+	ir_mode      *mode   = get_ir_mode(type->bitfield.base_type);
 	ir_node      *addr   = expression_to_addr(select);
 
 	assert(get_irn_mode(value) == mode);
@@ -1606,6 +1493,11 @@ static void bitfield_store_to_firm(const unary_expression_t *expression,
 	ir_node *store     = new_d_Store(dbgi, load_mem, addr, new_val);
 	ir_node *store_mem = new_d_Proj(dbgi, store, mode_M, pn_Store_M);
 	set_store(store_mem);
+
+	if(type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) {
+		set_Load_volatility(load, volatility_is_volatile);
+		set_Store_volatility(store, volatility_is_volatile);
+	}
 }
 
 static void set_value_for_expression(const expression_t *expression,
@@ -1819,7 +1711,7 @@ static ir_node *bitfield_extract_to_firm(const unary_expression_t *expression)
 
 	type_t   *type     = select->base.type;
 	assert(type->kind == TYPE_BITFIELD);
-	ir_mode  *mode     = get_ir_mode(type->bitfield.base);
+	ir_mode  *mode     = get_ir_mode(type->bitfield.base_type);
 	dbg_info *dbgi     = get_dbg_info(&expression->base.source_position);
 	ir_node  *addr     = expression_to_addr(select);
 	ir_node  *mem      = get_store();
@@ -1894,9 +1786,8 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
 	case EXPR_UNARY_DEREFERENCE: {
 		ir_node *value_node = expression_to_firm(value);
 		type_t  *value_type = skip_typeref(value->base.type);
-		ir_type *irtype     = get_ir_type(value_type);
-		assert(is_Pointer_type(irtype));
-		ir_type *points_to  = get_pointer_points_to_type(irtype);
+		assert(is_type_pointer(value_type));
+		type_t  *points_to  = value_type->pointer.points_to;
 		return deref_address(points_to, value_node, dbgi);
 	}
 	case EXPR_UNARY_POSTFIX_INCREMENT:
@@ -1912,6 +1803,8 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
 			node = do_strict_conv(dbgi, node);
 			return node;
 		} else {
+			/* make sure firm type is constructed */
+			(void) get_ir_type(type);
 			return value_node;
 		}
 	}
@@ -2323,9 +2216,8 @@ static ir_node *array_access_to_firm(
 	type_t   *type   = revert_automatic_type_conversion(
 			(const expression_t*) expression);
 	type             = skip_typeref(type);
-	ir_type  *irtype = get_ir_type(type);
 
-	return deref_address(irtype, addr, dbgi);
+	return deref_address(type, addr, dbgi);
 }
 
 static long get_offsetof_offset(const offsetof_expression_t *expression)
@@ -2563,9 +2455,8 @@ static ir_node *select_to_firm(const select_expression_t *expression)
 	type_t   *type   = revert_automatic_type_conversion(
 			(const expression_t*) expression);
 	type             = skip_typeref(type);
-	ir_type  *irtype = get_ir_type(type);
 
-	return deref_address(irtype, addr, dbgi);
+	return deref_address(type, addr, dbgi);
 }
 
 /* Values returned by __builtin_classify_type. */
@@ -2595,23 +2486,23 @@ typedef enum gcc_type_class
 
 static ir_node *classify_type_to_firm(const classify_type_expression_t *const expr)
 {
-	const type_t *const type = expr->type_expression->base.type;
+	const type_t *const type = skip_typeref(expr->type_expression->base.type);
 
 	gcc_type_class tc;
 	switch (type->kind)
 	{
 		case TYPE_ATOMIC: {
 			const atomic_type_t *const atomic_type = &type->atomic;
-			switch (atomic_type->akind) {
+			switch ((atomic_type_kind_t) atomic_type->akind) {
 				/* should not be reached */
 				case ATOMIC_TYPE_INVALID:
 					tc = no_type_class;
-					break;
+					goto make_const;
 
 				/* gcc cannot do that */
 				case ATOMIC_TYPE_VOID:
 					tc = void_type_class;
-					break;
+					goto make_const;
 
 				case ATOMIC_TYPE_CHAR:      /* gcc handles this as integer */
 				case ATOMIC_TYPE_SCHAR:     /* gcc handles this as integer */
@@ -2626,46 +2517,49 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex
 				case ATOMIC_TYPE_ULONGLONG:
 				case ATOMIC_TYPE_BOOL:      /* gcc handles this as integer */
 					tc = integer_type_class;
-					break;
+					goto make_const;
 
 				case ATOMIC_TYPE_FLOAT:
 				case ATOMIC_TYPE_DOUBLE:
 				case ATOMIC_TYPE_LONG_DOUBLE:
 					tc = real_type_class;
-					break;
+					goto make_const;
 
-#ifdef PROVIDE_COMPLEX
 				case ATOMIC_TYPE_FLOAT_COMPLEX:
 				case ATOMIC_TYPE_DOUBLE_COMPLEX:
 				case ATOMIC_TYPE_LONG_DOUBLE_COMPLEX:
 					tc = complex_type_class;
-					break;
+					goto make_const;
 				case ATOMIC_TYPE_FLOAT_IMAGINARY:
 				case ATOMIC_TYPE_DOUBLE_IMAGINARY:
 				case ATOMIC_TYPE_LONG_DOUBLE_IMAGINARY:
 					tc = complex_type_class;
-					break;
-#endif
-
-				default:
-					panic("Unimplemented case in classify_type_to_firm().");
+					goto make_const;
 			}
-			break;
+			panic("Unexpected atomic type in classify_type_to_firm().");
 		}
 
+		case TYPE_BITFIELD:        tc = integer_type_class; goto make_const;
 		case TYPE_ARRAY:           /* gcc handles this as pointer */
 		case TYPE_FUNCTION:        /* gcc handles this as pointer */
-		case TYPE_POINTER:         tc = pointer_type_class; break;
-		case TYPE_COMPOUND_STRUCT: tc = record_type_class;  break;
-		case TYPE_COMPOUND_UNION:  tc = union_type_class;   break;
+		case TYPE_POINTER:         tc = pointer_type_class; goto make_const;
+		case TYPE_COMPOUND_STRUCT: tc = record_type_class;  goto make_const;
+		case TYPE_COMPOUND_UNION:  tc = union_type_class;   goto make_const;
 
 		/* gcc handles this as integer */
-		case TYPE_ENUM:            tc = integer_type_class; break;
-
-		default:
-			panic("Unimplemented case in classify_type_to_firm().");
+		case TYPE_ENUM:            tc = integer_type_class; goto make_const;
+
+		case TYPE_BUILTIN:
+		/* typedef/typeof should be skipped already */
+		case TYPE_TYPEDEF:
+		case TYPE_TYPEOF:
+		case TYPE_INVALID:
+		case TYPE_ERROR:
+			break;
 	}
+	panic("unexpected TYPE classify_type_to_firm().");
 
+make_const: ;
 	dbg_info *const dbgi = get_dbg_info(&expr->base.source_position);
 	ir_mode  *const mode = mode_int;
 	tarval   *const tv   = new_tarval_from_long(tc, mode);
@@ -2673,16 +2567,30 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex
 }
 
 static ir_node *function_name_to_firm(
-		const string_literal_expression_t *const expr)
-{
-	if (current_function_name == NULL) {
-		const source_position_t *const src_pos = &expr->base.source_position;
-		const char *const name = current_function_decl->symbol->string;
-		const string_t string = { name, strlen(name) + 1 };
-		current_function_name = string_to_firm(src_pos, "__func__", &string);
+		const funcname_expression_t *const expr)
+{
+	switch(expr->kind) {
+	case FUNCNAME_FUNCTION:
+	case FUNCNAME_PRETTY_FUNCTION:
+	case FUNCNAME_FUNCDNAME:
+		if (current_function_name == NULL) {
+			const source_position_t *const src_pos = &expr->base.source_position;
+			const char *const name = current_function_decl->symbol->string;
+			const string_t string = { name, strlen(name) + 1 };
+			current_function_name = string_to_firm(src_pos, "__func__", &string);
+		}
+		return current_function_name;
+	case FUNCNAME_FUNCSIG:
+		if (current_funcsig == NULL) {
+			const source_position_t *const src_pos = &expr->base.source_position;
+			ir_entity *ent = get_irg_entity(current_ir_graph);
+			const char *const name = get_entity_ld_name(ent);
+			const string_t string = { name, strlen(name) + 1 };
+			current_funcsig = string_to_firm(src_pos, "__FUNCSIG__", &string);
+		}
+		return current_funcsig;
 	}
-
-	return current_function_name;
+	panic("Unsupported function name");
 }
 
 static ir_node *statement_expression_to_firm(const statement_expression_t *expr)
@@ -2714,13 +2622,13 @@ static ir_node *va_start_expression_to_firm(
 
 static ir_node *va_arg_expression_to_firm(const va_arg_expression_t *const expr)
 {
-	ir_type  *const irtype = get_ir_type(expr->base.type);
+	type_t   *const type   = expr->base.type;
 	ir_node  *const ap     = expression_to_firm(expr->ap);
 	dbg_info *const dbgi   = get_dbg_info(&expr->base.source_position);
-	ir_node  *const res    = deref_address(irtype, ap, dbgi);
+	ir_node  *const res    = deref_address(type, ap, dbgi);
 
-	ir_node  *const cnst      = get_type_size(expr->base.type);
-	ir_node  *const add       = new_d_Add(dbgi, ap, cnst, mode_P_data);
+	ir_node  *const cnst   = get_type_size(expr->base.type);
+	ir_node  *const add    = new_d_Add(dbgi, ap, cnst, mode_P_data);
 	set_value_for_expression(expr->ap, add);
 
 	return res;
@@ -2808,9 +2716,8 @@ static ir_node *_expression_to_firm(const expression_t *expression)
 		return select_to_firm(&expression->select);
 	case EXPR_CLASSIFY_TYPE:
 		return classify_type_to_firm(&expression->classify_type);
-	case EXPR_FUNCTION:
-	case EXPR_PRETTY_FUNCTION:
-		return function_name_to_firm(&expression->string);
+	case EXPR_FUNCNAME:
+		return function_name_to_firm(&expression->funcname);
 	case EXPR_STATEMENT:
 		return statement_expression_to_firm(&expression->statement);
 	case EXPR_VA_START:
@@ -2944,7 +2851,8 @@ static void create_declaration_entity(declaration_t *declaration,
                                       ir_type *parent_type)
 {
 	ident     *const id     = new_id_from_str(declaration->symbol->string);
-	ir_type   *const irtype = get_ir_type(declaration->type);
+	type_t    *const type   = skip_typeref(declaration->type);
+	ir_type   *const irtype = get_ir_type(type);
 	dbg_info  *const dbgi   = get_dbg_info(&declaration->source_position);
 	ir_entity *const entity = new_d_entity(parent_type, id, irtype, dbgi);
 	set_entity_ld_ident(entity, id);
@@ -2956,7 +2864,10 @@ static void create_declaration_entity(declaration_t *declaration,
 		set_entity_allocation(entity, allocation_automatic);
 	else if(declaration_kind == DECLARATION_KIND_GLOBAL_VARIABLE)
 		set_entity_allocation(entity, allocation_static);
-	/* TODO: visibility? */
+
+	if(type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) {
+		set_entity_volatility(entity, volatility_is_volatile);
+	}
 }
 
 
@@ -2986,7 +2897,7 @@ static __attribute__((unused)) void debug_print_type_path(const type_path_t *pat
 		if(is_type_compound(type)) {
 			fprintf(stderr, ".%s", entry->compound_entry->symbol->string);
 		} else if(is_type_array(type)) {
-			fprintf(stderr, "[%u]", entry->index);
+			fprintf(stderr, "[%zd]", entry->index);
 		} else {
 			fprintf(stderr, "-INVALID-");
 		}
@@ -3265,6 +3176,8 @@ static ir_initializer_t *create_ir_initializer_list(
 static ir_initializer_t *create_ir_initializer_string(
 		const initializer_string_t *initializer, type_t *type)
 {
+	type = skip_typeref(type);
+
 	size_t            string_len    = initializer->string.size;
 	assert(type->kind == TYPE_ARRAY && type->array.size_constant);
 	size_t            len           = type->array.size;
@@ -3335,14 +3248,29 @@ static ir_initializer_t *create_ir_initializer(
 	panic("unknown initializer");
 }
 
+static void create_dynamic_null_initializer(ir_type *type, dbg_info *dbgi,
+                                            ir_node *base_addr)
+{
+	ir_mode *mode = get_type_mode(type);
+	tarval  *zero = get_mode_null(mode);
+	ir_node *cnst = new_d_Const(dbgi, mode, zero);
+
+	/* TODO: bitfields */
+	ir_node *mem    = get_store();
+	ir_node *store  = new_d_Store(dbgi, mem, base_addr, cnst);
+	ir_node *proj_m = new_Proj(store, mode_M, pn_Store_M);
+	set_store(proj_m);
+}
+
 static void create_dynamic_initializer_sub(ir_initializer_t *initializer,
 		ir_type *type, dbg_info *dbgi, ir_node *base_addr)
 {
 	switch(get_initializer_kind(initializer)) {
 	case IR_INITIALIZER_NULL: {
-		ir_mode *mode = get_type_mode(type);
 		/* TODO: implement this for compound types... */
 		assert(type != NULL);
+
+		ir_mode *mode = get_type_mode(type);
 		tarval  *zero = get_mode_null(mode);
 		ir_node *cnst = new_d_Const(dbgi, mode, zero);
 
@@ -3577,6 +3505,8 @@ static void create_local_variable(declaration_t *declaration)
 		return;
 	} else if(is_type_array(type) || is_type_compound(type)) {
 		needs_entity = true;
+	} else if(type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) {
+		needs_entity = true;
 	}
 
 	if(needs_entity) {
@@ -3606,6 +3536,10 @@ static void create_local_static_variable(declaration_t *declaration)
 	ir_entity *const entity      = new_d_entity(global_type, id, irtype, dbgi);
 	set_entity_ld_ident(entity, id);
 
+	if(type->base.qualifiers & TYPE_QUALIFIER_VOLATILE) {
+		set_entity_volatility(entity, volatility_is_volatile);
+	}
+
 	declaration->declaration_kind = DECLARATION_KIND_GLOBAL_VARIABLE;
 	declaration->v.entity         = entity;
 	set_entity_variability(entity, variability_uninitialized);
@@ -4281,11 +4215,24 @@ static void asm_statement_to_firm(const asm_statement_t *statement)
 #endif
 }
 
+static void	ms_try_statement_to_firm(ms_try_statement_t *statement) {
+	statement_to_firm(statement->try_statement);
+	warningf(&statement->base.source_position, "structured exception handling ignored");
+}
+
+static void	leave_statement_to_firm(leave_statement_t *statement) {
+	errorf(&statement->base.source_position, "__leave not supported yet");
+}
+
 static void statement_to_firm(statement_t *statement)
 {
 	switch(statement->kind) {
 	case STATEMENT_INVALID:
 		panic("invalid statement found");
+		return;
+	case STATEMENT_EMPTY:
+		/* nothing */
+		return;
 	case STATEMENT_COMPOUND:
 		compound_statement_to_firm(&statement->compound);
 		return;
@@ -4331,6 +4278,12 @@ static void statement_to_firm(statement_t *statement)
 	case STATEMENT_ASM:
 		asm_statement_to_firm(&statement->asms);
 		return;
+	case STATEMENT_MS_TRY:
+		ms_try_statement_to_firm(&statement->ms_try);
+		return;
+	case STATEMENT_LEAVE:
+		leave_statement_to_firm(&statement->leave);
+		return;
 	}
 	panic("Statement not implemented\n");
 }
@@ -4357,10 +4310,12 @@ static int count_local_declarations(const declaration_t *      decl,
 }
 
 static int count_decls_in_expression(const expression_t *expression) {
+	int count = 0;
+
 	if(expression == NULL)
 		return 0;
 
-	switch(expression->base.kind) {
+	switch((expression_kind_t) expression->base.kind) {
 	case EXPR_STATEMENT:
 		return count_decls_in_stmts(expression->statement.statement);
 	EXPR_BINARY_CASES {
@@ -4371,7 +4326,6 @@ static int count_decls_in_expression(const expression_t *expression) {
 	EXPR_UNARY_CASES
 		return count_decls_in_expression(expression->unary.value);
 	case EXPR_CALL:	{
-		int count = 0;
 		call_argument_t *argument = expression->call.arguments;
 		for( ; argument != NULL; argument = argument->next) {
 			count += count_decls_in_expression(argument->expression);
@@ -4379,7 +4333,63 @@ static int count_decls_in_expression(const expression_t *expression) {
 		return count;
 	}
 
-	default:
+	case EXPR_UNKNOWN:
+	case EXPR_INVALID:
+		panic("unexpected expression kind");
+
+	case EXPR_COMPOUND_LITERAL:
+		/* TODO... */
+		break;
+
+	case EXPR_CONDITIONAL:
+		count += count_decls_in_expression(expression->conditional.condition);
+		count += count_decls_in_expression(expression->conditional.true_expression);
+		count += count_decls_in_expression(expression->conditional.false_expression);
+		return count;
+
+	case EXPR_BUILTIN_PREFETCH:
+		count += count_decls_in_expression(expression->builtin_prefetch.adr);
+		count += count_decls_in_expression(expression->builtin_prefetch.rw);
+		count += count_decls_in_expression(expression->builtin_prefetch.locality);
+		return count;
+
+	case EXPR_BUILTIN_CONSTANT_P:
+		count += count_decls_in_expression(expression->builtin_constant.value);
+		return count;
+
+	case EXPR_SELECT:
+		count += count_decls_in_expression(expression->select.compound);
+		return count;
+
+	case EXPR_ARRAY_ACCESS:
+		count += count_decls_in_expression(expression->array_access.array_ref);
+		count += count_decls_in_expression(expression->array_access.index);
+		return count;
+
+	case EXPR_CLASSIFY_TYPE:
+		count += count_decls_in_expression(expression->classify_type.type_expression);
+		return count;
+
+	case EXPR_SIZEOF:
+	case EXPR_ALIGNOF: {
+		expression_t *tp_expression = expression->typeprop.tp_expression;
+		if (tp_expression != NULL) {
+			count += count_decls_in_expression(tp_expression);
+		}
+		return count;
+	}
+
+	case EXPR_OFFSETOF:
+	case EXPR_REFERENCE:
+	case EXPR_CONST:
+	case EXPR_CHARACTER_CONSTANT:
+	case EXPR_WIDE_CHARACTER_CONSTANT:
+	case EXPR_STRING_LITERAL:
+	case EXPR_WIDE_STRING_LITERAL:
+	case EXPR_FUNCNAME:
+	case EXPR_BUILTIN_SYMBOL:
+	case EXPR_VA_START:
+	case EXPR_VA_ARG:
 		break;
 	}
 
@@ -4395,6 +4405,9 @@ static int count_decls_in_stmts(const statement_t *stmt)
 	int count = 0;
 	for (; stmt != NULL; stmt = stmt->base.next) {
 		switch (stmt->kind) {
+			case STATEMENT_EMPTY:
+				break;
+
 			case STATEMENT_DECLARATION: {
 				const declaration_statement_t *const decl_stmt = &stmt->declaration;
 				count += count_local_declarations(decl_stmt->declarations_begin,
@@ -4477,6 +4490,7 @@ static int count_decls_in_stmts(const statement_t *stmt)
 			}
 
 			case STATEMENT_GOTO:
+			case STATEMENT_LEAVE:
 			case STATEMENT_INVALID:
 				break;
 
@@ -4485,6 +4499,15 @@ static int count_decls_in_stmts(const statement_t *stmt)
 				count += count_decls_in_expression(ret_stmt->value);
 				break;
 			}
+
+			case STATEMENT_MS_TRY: {
+				const ms_try_statement_t *const try_stmt = &stmt->ms_try;
+				count += count_decls_in_stmts(try_stmt->try_statement);
+				if(try_stmt->except_expression != NULL)
+					count += count_decls_in_expression(try_stmt->except_expression);
+				count += count_decls_in_stmts(try_stmt->final_statement);
+				break;
+			}
 		}
 	}
 	return count;
@@ -4590,6 +4613,7 @@ static void create_function(declaration_t *declaration)
 
 	current_function_decl = declaration;
 	current_function_name = NULL;
+	current_funcsig       = NULL;
 
 	assert(imature_blocks == NULL);
 	imature_blocks = NEW_ARR_F(ir_node*, 0);
@@ -4750,10 +4774,7 @@ static void init_ir_types(void)
 	ir_type_int        = get_ir_type(type_int);
 	ir_type_const_char = get_ir_type(type_const_char);
 	ir_type_wchar_t    = get_ir_type(type_wchar_t);
-	ir_type_void       = get_ir_type(type_int); /* we don't have a real void
-	                                               type in firm */
-
-	type_void->base.firm_type = ir_type_void;
+	ir_type_void       = get_ir_type(type_void);
 }
 
 void exit_ast2firm(void)