X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast2firm.c;h=559b1c21379b92338c2d575f17eb976f1a68d65f;hb=e628f683385763274b551d468107872a058b31d7;hp=50ab3254d961a325a6d0824beb53dca0b5afba35;hpb=fbbb2b6932bdd8455b850b750d93b4d5584402a7;p=cparser

diff --git a/ast2firm.c b/ast2firm.c
index 50ab325..559b1c2 100644
--- a/ast2firm.c
+++ b/ast2firm.c
@@ -49,7 +49,6 @@
 #include "printer.h"
 #include "entitymap_t.h"
 #include "driver/firm_opt.h"
-#include "driver/firm_cmdline.h"
 
 typedef struct trampoline_region trampoline_region;
 struct trampoline_region {
@@ -57,6 +56,8 @@ struct trampoline_region {
 	ir_entity        *region;      /**< created region for the trampoline */
 };
 
+fp_model_t firm_fp_model = fp_model_precise;
+
 static const backend_params *be_params;
 
 static ir_type *ir_type_char;
@@ -82,8 +83,6 @@ static ir_node   *ijmp_list;
 static bool       constant_folding;
 static bool       initializer_use_bitfield_basetype;
 
-extern bool       have_const_functions;
-
 static const entity_t     *current_function_entity;
 static ir_node            *current_function_name;
 static ir_node            *current_funcsig;
@@ -113,12 +112,6 @@ typedef enum declaration_kind_t {
 } declaration_kind_t;
 
 static ir_mode *get_ir_mode_storage(type_t *type);
-/*
- * get arithmetic mode for a type. This is different from get_ir_mode_storage,
- * int that it returns bigger modes for floating point on some platforms
- * (x87 internally does arithemtic with 80bits)
- */
-static ir_mode *get_ir_mode_arithmetic(type_t *type);
 
 static ir_type *get_ir_type_incomplete(type_t *type);
 
@@ -133,11 +126,9 @@ static ir_node *uninitialized_local_var(ir_graph *irg, ir_mode *mode, int pos)
 {
 	const entity_t *entity = get_irg_loc_description(irg, pos);
 
-	if (entity != NULL && warning.uninitialized) {
-		warningf(&entity->base.source_position,
-		         "%s '%#T' might be used uninitialized",
-		         get_entity_kind_name(entity->kind),
-		         entity->declaration.type, entity->base.symbol);
+	if (entity != NULL) {
+		source_position_t const *const pos = &entity->base.source_position;
+		warningf(WARN_UNINITIALIZED, pos, "'%N' might be used uninitialized", entity);
 	}
 	return new_r_Unknown(irg, mode);
 }
@@ -148,7 +139,7 @@ static const char *dbg_retrieve(const dbg_info *dbg, unsigned *line)
 	if (pos == NULL)
 		return NULL;
 	if (line != NULL)
-		*line = pos->linenr;
+		*line = pos->lineno;
 	return pos->input_name;
 }
 
@@ -172,6 +163,18 @@ static type_dbg_info *get_type_dbg_info_(const type_t *type)
 	return (type_dbg_info*) type;
 }
 
+/* is the current block a reachable one? */
+static bool currently_reachable(void)
+{
+	ir_node *const block = get_cur_block();
+	return block != NULL && !is_Bad(block);
+}
+
+static void set_unreachable_now(void)
+{
+	set_cur_block(NULL);
+}
+
 static ir_mode *atomic_modes[ATOMIC_TYPE_LAST+1];
 
 static ir_mode *mode_int, *mode_uint;
@@ -425,9 +428,9 @@ static ir_type *create_pointer_type(pointer_type_t *type)
 	type_dbg_info *dbgi         = get_type_dbg_info_((const type_t*) type);
 	type_t        *points_to    = type->points_to;
 	ir_type       *ir_points_to = get_ir_type_incomplete(points_to);
-	ir_type       *ir_type      = new_d_type_pointer(ir_points_to, dbgi);
+	ir_type       *irtype       = new_d_type_pointer(ir_points_to, dbgi);
 
-	return ir_type;
+	return irtype;
 }
 
 static ir_type *create_reference_type(reference_type_t *type)
@@ -435,9 +438,9 @@ static ir_type *create_reference_type(reference_type_t *type)
 	type_dbg_info *dbgi         = get_type_dbg_info_((const type_t*) type);
 	type_t        *refers_to    = type->refers_to;
 	ir_type       *ir_refers_to = get_ir_type_incomplete(refers_to);
-	ir_type       *ir_type      = new_d_type_pointer(ir_refers_to, dbgi);
+	ir_type       *irtype       = new_d_type_pointer(ir_refers_to, dbgi);
 
-	return ir_type;
+	return irtype;
 }
 
 static ir_type *create_array_type(array_type_t *type)
@@ -445,27 +448,27 @@ static ir_type *create_array_type(array_type_t *type)
 	type_dbg_info *dbgi            = get_type_dbg_info_((const type_t*) type);
 	type_t        *element_type    = type->element_type;
 	ir_type       *ir_element_type = get_ir_type(element_type);
-	ir_type       *ir_type         = new_d_type_array(1, ir_element_type, dbgi);
+	ir_type       *irtype          = new_d_type_array(1, ir_element_type, dbgi);
 
 	const int align = get_type_alignment_bytes(ir_element_type);
-	set_type_alignment_bytes(ir_type, align);
+	set_type_alignment_bytes(irtype, align);
 
 	if (type->size_constant) {
 		int n_elements = type->size;
 
-		set_array_bounds_int(ir_type, 0, 0, n_elements);
+		set_array_bounds_int(irtype, 0, 0, n_elements);
 
 		size_t elemsize = get_type_size_bytes(ir_element_type);
 		if (elemsize % align > 0) {
 			elemsize += align - (elemsize % align);
 		}
-		set_type_size_bytes(ir_type, n_elements * elemsize);
+		set_type_size_bytes(irtype, n_elements * elemsize);
 	} else {
-		set_array_lower_bound_int(ir_type, 0, 0);
+		set_array_lower_bound_int(irtype, 0, 0);
 	}
-	set_type_state(ir_type, layout_fixed);
+	set_type_state(irtype, layout_fixed);
 
-	return ir_type;
+	return irtype;
 }
 
 /**
@@ -571,10 +574,10 @@ static ir_type *create_compound_type(compound_type_t *type,
 		return compound->irtype;
 	}
 
-	symbol_t *symbol = compound->base.symbol;
+	symbol_t *type_symbol = compound->base.symbol;
 	ident    *id;
-	if (symbol != NULL) {
-		id = new_id_from_str(symbol->string);
+	if (type_symbol != NULL) {
+		id = new_id_from_str(type_symbol->string);
 	} else {
 		if (is_union) {
 			id = id_unique("__anonymous_union.%u");
@@ -745,9 +748,6 @@ ir_type *get_ir_type(type_t *type)
 	case TYPE_ENUM:
 		firm_type = create_enum_type(&type->enumt);
 		break;
-	case TYPE_BUILTIN:
-		firm_type = get_ir_type(type->builtin.real_type);
-		break;
 	case TYPE_BITFIELD:
 		firm_type = create_bitfield_type(&type->bitfield);
 		break;
@@ -778,6 +778,11 @@ static ir_mode *get_ir_mode_storage(type_t *type)
 	return mode;
 }
 
+/*
+ * get arithmetic mode for a type. This is different from get_ir_mode_storage,
+ * int that it returns bigger modes for floating point on some platforms
+ * (x87 internally does arithemtic with 80bits)
+ */
 static ir_mode *get_ir_mode_arithmetic(type_t *type)
 {
 	ir_mode *mode = get_ir_mode_storage(type);
@@ -901,7 +906,6 @@ static void handle_decl_modifiers(ir_entity *irentity, entity_t *entity)
 		}
 		if (modifiers & DM_CONST) {
 			add_entity_additional_properties(irentity, mtp_property_const);
-			have_const_functions = true;
 		}
 	}
 	if (modifiers & DM_USED) {
@@ -1068,23 +1072,21 @@ entity_created:
  * Creates a SymConst for a given entity.
  *
  * @param dbgi    debug info
- * @param mode    the (reference) mode for the SymConst
  * @param entity  the entity
  */
-static ir_node *create_symconst(dbg_info *dbgi, ir_mode *mode,
-                                ir_entity *entity)
+static ir_node *create_symconst(dbg_info *dbgi, ir_entity *entity)
 {
 	assert(entity != NULL);
 	union symconst_symbol sym;
 	sym.entity_p = entity;
-	return new_d_SymConst(dbgi, mode, sym, symconst_addr_ent);
+	return new_d_SymConst(dbgi, mode_P, sym, symconst_addr_ent);
 }
 
 static ir_node *create_conv(dbg_info *dbgi, ir_node *value, ir_mode *dest_mode)
 {
 	ir_mode *value_mode = get_irn_mode(value);
 
-	if (value_mode == dest_mode || is_Bad(value))
+	if (value_mode == dest_mode)
 		return value;
 
 	if (dest_mode == mode_b) {
@@ -1139,7 +1141,7 @@ static ir_node *wide_string_literal_to_firm(
 	}
 	set_entity_initializer(entity, initializer);
 
-	return create_symconst(dbgi, mode_P_data, entity);
+	return create_symconst(dbgi, entity);
 }
 
 /**
@@ -1182,7 +1184,7 @@ static ir_node *string_to_firm(const source_position_t *const src_pos,
 	}
 	set_entity_initializer(entity, initializer);
 
-	return create_symconst(dbgi, mode_P_data, entity);
+	return create_symconst(dbgi, entity);
 }
 
 static bool try_create_integer(literal_expression_t *literal,
@@ -1422,7 +1424,7 @@ static ir_node *create_trampoline(dbg_info *dbgi, ir_mode *mode,
 	assert(entity != NULL);
 	ir_node *in[3];
 	in[0] = get_trampoline_region(dbgi, entity);
-	in[1] = create_symconst(dbgi, mode, entity);
+	in[1] = create_symconst(dbgi, entity);
 	in[2] = get_irg_frame(current_ir_graph);
 
 	ir_node *irn = new_d_Builtin(dbgi, get_store(), 3, in, ir_bk_inner_trampoline, get_unknown_type());
@@ -1487,25 +1489,6 @@ static ir_node *do_strict_conv(dbg_info *dbgi, ir_node *node)
 	return new_d_strictConv(dbgi, node, mode);
 }
 
-/**
- * Returns the address of a global variable.
- *
- * @param dbgi      debug info
- * @param variable  the variable
- */
-static ir_node *get_global_var_address(dbg_info *const dbgi,
-                                       const variable_t *const variable)
-{
-	ir_entity *const irentity = variable->v.entity;
-	if (variable->thread_local) {
-		ir_node *const no_mem = new_NoMem();
-		ir_node *const tls    = get_irg_tls(current_ir_graph);
-		return new_d_simpleSel(dbgi, no_mem, tls, irentity);
-	} else {
-		return create_symconst(dbgi, mode_P_data, irentity);
-	}
-}
-
 /**
  * Returns the correct base address depending on whether it is a parameter or a
  * normal local variable.
@@ -1561,11 +1544,9 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
 		/* for gcc compatibility we have to produce (dummy) addresses for some
 		 * builtins which don't have entities */
 		if (irentity == NULL) {
-			if (warning.other) {
-				warningf(&ref->base.source_position,
-						"taking address of builtin '%Y'",
-						ref->entity->base.symbol);
-			}
+			source_position_t const *const pos = &ref->base.source_position;
+			symbol_t          const *const sym = ref->entity->base.symbol;
+			warningf(WARN_OTHER, pos, "taking address of builtin '%Y'", sym);
 
 			/* simply create a NULL pointer */
 			ir_mode  *mode = get_ir_mode_arithmetic(type_void_ptr);
@@ -1590,14 +1571,13 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
 		return create_conv(NULL, value, get_ir_mode_arithmetic(type));
 	}
 	case DECLARATION_KIND_FUNCTION: {
-		ir_mode *const mode = get_ir_mode_storage(type);
-		return create_symconst(dbgi, mode, entity->function.irentity);
+		return create_symconst(dbgi, entity->function.irentity);
 	}
 	case DECLARATION_KIND_INNER_FUNCTION: {
 		ir_mode *const mode = get_ir_mode_storage(type);
 		if (!entity->function.goto_to_outer && !entity->function.need_closure) {
 			/* inner function not using the closure */
-			return create_symconst(dbgi, mode, entity->function.irentity);
+			return create_symconst(dbgi, entity->function.irentity);
 		} else {
 			/* need trampoline here */
 			return create_trampoline(dbgi, mode, entity->function.irentity);
@@ -1605,7 +1585,7 @@ static ir_node *reference_expression_to_firm(const reference_expression_t *ref)
 	}
 	case DECLARATION_KIND_GLOBAL_VARIABLE: {
 		const variable_t *variable = &entity->variable;
-		ir_node *const addr = get_global_var_address(dbgi, variable);
+		ir_node *const addr = create_symconst(dbgi, variable->v.entity);
 		return deref_address(dbgi, variable->base.type, addr);
 	}
 
@@ -1647,7 +1627,7 @@ static ir_node *reference_addr(const reference_expression_t *ref)
 		 * as an indicator for no real address) */
 		return NULL;
 	case DECLARATION_KIND_GLOBAL_VARIABLE: {
-		ir_node *const addr = get_global_var_address(dbgi, &entity->variable);
+		ir_node *const addr = create_symconst(dbgi, entity->variable.v.entity);
 		return addr;
 	}
 	case DECLARATION_KIND_LOCAL_VARIABLE_ENTITY: {
@@ -1669,9 +1649,7 @@ static ir_node *reference_addr(const reference_expression_t *ref)
 		return entity->variable.v.vla_base;
 
 	case DECLARATION_KIND_FUNCTION: {
-		type_t  *const type = skip_typeref(entity->declaration.type);
-		ir_mode *const mode = get_ir_mode_storage(type);
-		return create_symconst(dbgi, mode, entity->function.irentity);
+		return create_symconst(dbgi, entity->function.irentity);
 	}
 
 	case DECLARATION_KIND_INNER_FUNCTION: {
@@ -1679,7 +1657,7 @@ static ir_node *reference_addr(const reference_expression_t *ref)
 		ir_mode *const mode = get_ir_mode_storage(type);
 		if (!entity->function.goto_to_outer && !entity->function.need_closure) {
 			/* inner function not using the closure */
-			return create_symconst(dbgi, mode, entity->function.irentity);
+			return create_symconst(dbgi, entity->function.irentity);
 		} else {
 			/* need trampoline here */
 			return create_trampoline(dbgi, mode, entity->function.irentity);
@@ -1769,10 +1747,10 @@ static ir_node *process_builtin_call(const call_expression_t *call)
 	assert(call->function->kind == EXPR_REFERENCE);
 	reference_expression_t *builtin = &call->function->reference;
 
-	type_t *type = skip_typeref(builtin->base.type);
-	assert(is_type_pointer(type));
+	type_t *expr_type = skip_typeref(builtin->base.type);
+	assert(is_type_pointer(expr_type));
 
-	type_t *function_type = skip_typeref(type->pointer.points_to);
+	type_t *function_type = skip_typeref(expr_type->pointer.points_to);
 
 	switch (builtin->entity->function.btk) {
 	case bk_gnu_builtin_alloca: {
@@ -1967,7 +1945,7 @@ static ir_node *process_builtin_call(const call_expression_t *call)
 static ir_node *call_expression_to_firm(const call_expression_t *const call)
 {
 	dbg_info *const dbgi = get_dbg_info(&call->base.source_position);
-	assert(get_cur_block() != NULL);
+	assert(currently_reachable());
 
 	expression_t *function = call->function;
 	if (function->kind == EXPR_REFERENCE) {
@@ -2056,8 +2034,8 @@ static ir_node *call_expression_to_firm(const call_expression_t *const call)
 		expression_t *expression = argument->expression;
 		ir_node      *arg_node   = expression_to_firm(expression);
 
-		type_t  *type = skip_typeref(expression->base.type);
-		if (!is_type_compound(type)) {
+		type_t *arg_type = skip_typeref(expression->base.type);
+		if (!is_type_compound(arg_type)) {
 			ir_mode *mode = get_ir_mode_storage(expression->base.type);
 			arg_node      = create_conv(dbgi, arg_node, mode);
 			arg_node      = do_strict_conv(dbgi, arg_node);
@@ -2475,7 +2453,7 @@ static ir_node *handle_assume_compare(dbg_info *dbi,
 		return res;
 	}
 
-	expression_t *con;
+	expression_t *con = NULL;
 	if (is_local_variable(op1) && is_constant_expression(op2) == EXPR_CLASS_CONSTANT) {
 		var = op1->reference.entity;
 		con = op2;
@@ -2540,12 +2518,12 @@ static ir_node *create_cast(dbg_info *dbgi, ir_node *value_node,
 		const variable_t *to_var   = type->pointer.base_variable;
 		if (from_var != to_var) {
 			if (from_var != NULL) {
-				ir_node *const addr = get_global_var_address(dbgi, from_var);
+				ir_node *const addr = create_symconst(dbgi, from_var->v.entity);
 				ir_node *const base = deref_address(dbgi, from_var->base.type, addr);
 				value_node = new_d_Add(dbgi, value_node, base, get_ir_mode_storage(from_type));
 			}
 			if (to_var != NULL) {
-				ir_node *const addr = get_global_var_address(dbgi, to_var);
+				ir_node *const addr = create_symconst(dbgi, to_var->v.entity);
 				ir_node *const base = deref_address(dbgi, to_var->base.type, addr);
 				value_node = new_d_Sub(dbgi, value_node, base, mode);
 			}
@@ -2603,7 +2581,7 @@ static ir_node *unary_expression_to_firm(const unary_expression_t *expression)
 		/* check for __based */
 		const variable_t *const base_var = value_type->pointer.base_variable;
 		if (base_var != NULL) {
-			ir_node *const addr = get_global_var_address(dbgi, base_var);
+			ir_node *const addr = create_symconst(dbgi, base_var->v.entity);
 			ir_node *const base = deref_address(dbgi, base_var->base.type, addr);
 			value_node = new_d_Add(dbgi, value_node, base, get_ir_mode_storage(value_type));
 		}
@@ -2684,7 +2662,7 @@ static ir_node *create_op(dbg_info *dbgi, const binary_expression_t *expression,
 	case EXPR_BINARY_SHIFTRIGHT:
 	case EXPR_BINARY_SHIFTLEFT_ASSIGN:
 	case EXPR_BINARY_SHIFTRIGHT_ASSIGN:
-		mode  = get_irn_mode(left);
+		mode  = get_ir_mode_arithmetic(expression->base.type);
 		right = create_conv(dbgi, right, mode_uint);
 		break;
 
@@ -3344,7 +3322,6 @@ static ir_node *classify_type_to_firm(const classify_type_expression_t *const ex
 			/* gcc classifies the referenced type */
 			case TYPE_REFERENCE: type = type->reference.refers_to; continue;
 
-			case TYPE_BUILTIN:
 			/* typedef/typeof should be skipped already */
 			case TYPE_TYPEDEF:
 			case TYPE_TYPEOF:
@@ -3738,14 +3715,8 @@ static ir_node *create_condition_evaluation(const expression_t *expression,
 	if (is_builtin_expect(expression) && is_Cond(cond)) {
 		call_argument_t *argument = expression->call.arguments->next;
 		if (is_constant_expression(argument->expression) == EXPR_CLASS_CONSTANT) {
-			bool             cnst = fold_constant_to_bool(argument->expression);
-			cond_jmp_predicate pred;
-
-			if (cnst == false) {
-				pred = COND_JMP_PRED_FALSE;
-			} else {
-				pred = COND_JMP_PRED_TRUE;
-			}
+			bool               const cnst = fold_constant_to_bool(argument->expression);
+			cond_jmp_predicate const pred = cnst ? COND_JMP_PRED_TRUE : COND_JMP_PRED_FALSE;
 			set_Cond_jmp_pred(cond, pred);
 		}
 	}
@@ -3753,7 +3724,7 @@ static ir_node *create_condition_evaluation(const expression_t *expression,
 	add_immBlock_pred(true_block, true_proj);
 	add_immBlock_pred(false_block, false_proj);
 
-	set_cur_block(NULL);
+	set_unreachable_now();
 	return cond_expr;
 }
 
@@ -4435,7 +4406,7 @@ static void create_local_initializer(initializer_t *initializer, dbg_info *dbgi,
 
 	set_entity_initializer(init_entity, irinitializer);
 
-	ir_node *const src_addr = create_symconst(dbgi, mode_P_data, init_entity);
+	ir_node *const src_addr = create_symconst(dbgi, init_entity);
 	ir_node *const copyb    = new_d_CopyB(dbgi, memory, addr, src_addr, irtype);
 
 	ir_node *const copyb_mem = new_Proj(copyb, mode_M, pn_CopyB_M);
@@ -4476,8 +4447,8 @@ static void create_variable_initializer(entity_t *entity)
 
 		ir_node *value = expression_to_firm(initializer_value->value);
 
-		type_t  *type = initializer_value->value->base.type;
-		ir_mode *mode = get_ir_mode_storage(type);
+		type_t  *init_type = initializer_value->value->base.type;
+		ir_mode *mode      = get_ir_mode_storage(init_type);
 		value = create_conv(dbgi, value, mode);
 		value = do_strict_conv(dbgi, value);
 
@@ -4525,7 +4496,7 @@ static void allocate_variable_length_array(entity_t *entity)
 {
 	assert(entity->kind == ENTITY_VARIABLE);
 	assert(entity->variable.initializer == NULL);
-	assert(get_cur_block() != NULL);
+	assert(currently_reachable());
 
 	dbg_info *dbgi      = get_dbg_info(&entity->base.source_position);
 	type_t   *type      = entity->declaration.type;
@@ -4620,14 +4591,13 @@ static void create_local_static_variable(entity_t *entity)
 
 static void return_statement_to_firm(return_statement_t *statement)
 {
-	if (get_cur_block() == NULL)
+	if (!currently_reachable())
 		return;
 
 	dbg_info *dbgi        = get_dbg_info(&statement->base.source_position);
 	type_t   *type        = current_function_entity->declaration.type;
 	ir_type  *func_irtype = get_ir_type(type);
 
-
 	ir_node *in[1];
 	int      in_len;
 	if (get_method_n_ress(func_irtype) > 0) {
@@ -4636,10 +4606,10 @@ static void return_statement_to_firm(return_statement_t *statement)
 		if (statement->value != NULL) {
 			ir_node *node = expression_to_firm(statement->value);
 			if (!is_compound_type(res_type)) {
-				type_t  *type = statement->value->base.type;
-				ir_mode *mode = get_ir_mode_storage(type);
-				node          = create_conv(dbgi, node, mode);
-				node          = do_strict_conv(dbgi, node);
+				type_t  *ret_value_type = statement->value->base.type;
+				ir_mode *mode           = get_ir_mode_storage(ret_value_type);
+				node                    = create_conv(dbgi, node, mode);
+				node                    = do_strict_conv(dbgi, node);
 			}
 			in[0] = node;
 		} else {
@@ -4666,12 +4636,12 @@ static void return_statement_to_firm(return_statement_t *statement)
 	ir_node *end_block = get_irg_end_block(current_ir_graph);
 	add_immBlock_pred(end_block, ret);
 
-	set_cur_block(NULL);
+	set_unreachable_now();
 }
 
 static ir_node *expression_statement_to_firm(expression_statement_t *statement)
 {
-	if (get_cur_block() == NULL)
+	if (!currently_reachable())
 		return NULL;
 
 	return expression_to_firm(statement->expression);
@@ -4792,7 +4762,7 @@ static void initialize_local_declaration(entity_t *entity)
 
 	// no need to emit code in dead blocks
 	if (entity->declaration.storage_class != STORAGE_CLASS_STATIC
-			&& get_cur_block() == NULL)
+			&& !currently_reachable())
 		return;
 
 	switch ((declaration_kind_t) entity->declaration.kind) {
@@ -4849,7 +4819,7 @@ static void if_statement_to_firm(if_statement_t *statement)
 	/* Create the condition. */
 	ir_node *true_block  = NULL;
 	ir_node *false_block = NULL;
-	if (get_cur_block() != NULL) {
+	if (currently_reachable()) {
 		true_block  = new_immBlock();
 		false_block = new_immBlock();
 		create_condition_evaluation(statement->condition, true_block, false_block);
@@ -4866,7 +4836,7 @@ static void if_statement_to_firm(if_statement_t *statement)
 		}
 		set_cur_block(false_block);
 		statement_to_firm(statement->false_statement);
-		if (get_cur_block() != NULL) {
+		if (currently_reachable()) {
 			fallthrough_block = new_immBlock();
 			add_immBlock_pred(fallthrough_block, new_Jmp());
 		}
@@ -4877,7 +4847,7 @@ static void if_statement_to_firm(if_statement_t *statement)
 	/* Create the true statement. */
 	set_cur_block(true_block);
 	statement_to_firm(statement->true_statement);
-	if (get_cur_block() != NULL) {
+	if (currently_reachable()) {
 		if (fallthrough_block == NULL) {
 			fallthrough_block = new_immBlock();
 		}
@@ -4895,9 +4865,8 @@ static void if_statement_to_firm(if_statement_t *statement)
  * reachable. */
 static void jump_if_reachable(ir_node *const target_block)
 {
-	if (get_cur_block() != NULL) {
-		add_immBlock_pred(target_block, new_Jmp());
-	}
+	ir_node *const pred = currently_reachable() ? new_Jmp() : new_Bad(mode_X);
+	add_immBlock_pred(target_block, pred);
 }
 
 static void while_statement_to_firm(while_statement_t *statement)
@@ -5004,7 +4973,7 @@ static void for_statement_to_firm(for_statement_t *statement)
 		create_local_declaration(entity);
 	}
 
-	if (get_cur_block() != NULL) {
+	if (currently_reachable()) {
 		entity = statement->scope.entities;
 		for ( ; entity != NULL; entity = entity->base.next) {
 			if (!is_declaration(entity))
@@ -5082,14 +5051,14 @@ static void for_statement_to_firm(for_statement_t *statement)
 static void create_jump_statement(const statement_t *statement,
                                   ir_node *target_block)
 {
-	if (get_cur_block() == NULL)
+	if (!currently_reachable())
 		return;
 
 	dbg_info *dbgi = get_dbg_info(&statement->base.source_position);
 	ir_node  *jump = new_d_Jmp(dbgi);
 	add_immBlock_pred(target_block, jump);
 
-	set_cur_block(NULL);
+	set_unreachable_now();
 }
 
 static void switch_statement_to_firm(switch_statement_t *statement)
@@ -5098,13 +5067,13 @@ static void switch_statement_to_firm(switch_statement_t *statement)
 	dbg_info *dbgi        = get_dbg_info(&statement->base.source_position);
 	ir_node  *cond        = NULL;
 
-	if (get_cur_block() != NULL) {
+	if (currently_reachable()) {
 		ir_node *expression = expression_to_firm(statement->expression);
 		cond                = new_d_Cond(dbgi, expression);
 		first_block         = get_cur_block();
 	}
 
-	set_cur_block(NULL);
+	set_unreachable_now();
 
 	ir_node *const old_switch_cond       = current_switch_cond;
 	ir_node *const old_break_label       = break_label;
@@ -5129,7 +5098,7 @@ static void switch_statement_to_firm(switch_statement_t *statement)
 			default_proj_nr = l->last_case;
 	}
 
-	if (default_proj_nr == INT_MAX) {
+	if (default_proj_nr == LONG_MAX) {
 		/* Bad: an overflow will occur, we cannot be sure that the
 		 * maximum + 1 is a free number. Scan the values a second
 		 * time to find a free number.
@@ -5243,7 +5212,7 @@ static void label_to_firm(const label_statement_t *statement)
 
 static void goto_to_firm(const goto_statement_t *statement)
 {
-	if (get_cur_block() == NULL)
+	if (!currently_reachable())
 		return;
 
 	if (statement->expression) {
@@ -5258,7 +5227,7 @@ static void goto_to_firm(const goto_statement_t *statement)
 		ir_node *jmp   = new_Jmp();
 		add_immBlock_pred(block, jmp);
 	}
-	set_cur_block(NULL);
+	set_unreachable_now();
 }
 
 static void asm_statement_to_firm(const asm_statement_t *statement)
@@ -5321,20 +5290,19 @@ static void asm_statement_to_firm(const asm_statement_t *statement)
 		asm_constraint_flags_t asm_flags
 			= be_parse_asm_constraints(constraints);
 
-		if (asm_flags & ASM_CONSTRAINT_FLAG_NO_SUPPORT) {
-			warningf(&statement->base.source_position,
-			       "some constraints in '%s' are not supported", constraints);
-		}
-		if (asm_flags & ASM_CONSTRAINT_FLAG_INVALID) {
-			errorf(&statement->base.source_position,
-			       "some constraints in '%s' are invalid", constraints);
-			continue;
-		}
-		if (! (asm_flags & ASM_CONSTRAINT_FLAG_MODIFIER_WRITE)) {
-			errorf(&statement->base.source_position,
-			       "no write flag specified for output constraints '%s'",
-			       constraints);
-			continue;
+		{
+			source_position_t const *const pos = &statement->base.source_position;
+			if (asm_flags & ASM_CONSTRAINT_FLAG_NO_SUPPORT) {
+				warningf(WARN_OTHER, pos, "some constraints in '%s' are not supported", constraints);
+			}
+			if (asm_flags & ASM_CONSTRAINT_FLAG_INVALID) {
+				errorf(pos, "some constraints in '%s' are invalid", constraints);
+				continue;
+			}
+			if (! (asm_flags & ASM_CONSTRAINT_FLAG_MODIFIER_WRITE)) {
+				errorf(pos, "no write flag specified for output constraints '%s'", constraints);
+				continue;
+			}
 		}
 
 		unsigned pos = next_pos++;
@@ -5507,7 +5475,8 @@ static void asm_statement_to_firm(const asm_statement_t *statement)
 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");
+	source_position_t const *const pos = &statement->base.source_position;
+	warningf(WARN_OTHER, pos, "structured exception handling ignored");
 }
 
 static void leave_statement_to_firm(leave_statement_t *statement)
@@ -5681,13 +5650,13 @@ static void initialize_function_parameters(entity_t *entity)
 		}
 
 		if (needs_entity) {
-			ir_entity *entity = get_method_value_param_ent(function_irtype, n);
-			ident     *id     = new_id_from_str(parameter->base.symbol->string);
-			set_entity_ident(entity, id);
+			ir_entity *param = get_method_value_param_ent(function_irtype, n);
+			ident     *id    = new_id_from_str(parameter->base.symbol->string);
+			set_entity_ident(param, id);
 
 			parameter->declaration.kind
 				= DECLARATION_KIND_PARAMETER_ENTITY;
-			parameter->parameter.v.entity = entity;
+			parameter->parameter.v.entity = param;
 			continue;
 		}
 
@@ -5829,7 +5798,7 @@ static void create_function(entity_t *entity)
 	ir_graph *old_current_function = current_function;
 	current_function = irg;
 
-	set_irg_fp_model(irg, firm_opt.fp_model);
+	set_irg_fp_model(irg, firm_fp_model);
 	tarval_enable_fp_ops(1);
 	set_irn_dbg_info(get_irg_start_block(irg),
 	                 get_entity_dbg_info(function_entity));
@@ -5850,7 +5819,7 @@ static void create_function(entity_t *entity)
 	ir_node *end_block = get_irg_end_block(irg);
 
 	/* do we have a return statement yet? */
-	if (get_cur_block() != NULL) {
+	if (currently_reachable()) {
 		type_t *type = skip_typeref(entity->declaration.type);
 		assert(is_type_function(type));
 		const function_type_t *func_type   = &type->function;
@@ -5892,9 +5861,8 @@ static void create_function(entity_t *entity)
 	if (has_computed_gotos) {
 		/* if we have computed goto's in the function, we cannot inline it */
 		if (get_irg_inline_property(irg) >= irg_inline_recomended) {
-			warningf(&entity->base.source_position,
-			         "function '%Y' can never be inlined because it contains a computed goto",
-			         entity->base.symbol);
+			source_position_t const *const pos = &entity->base.source_position;
+			warningf(WARN_OTHER, pos, "'%N' can never be inlined because it contains a computed goto", entity);
 		}
 		set_irg_inline_property(irg, irg_inline_forbidden);
 	}
@@ -5913,8 +5881,8 @@ static void create_function(entity_t *entity)
 	int      align_all  = 4;
 	int      offset     = 0;
 	for (int i = 0; i < n; ++i) {
-		ir_entity *entity      = get_compound_member(frame_type, i);
-		ir_type   *entity_type = get_entity_type(entity);
+		ir_entity *member      = get_compound_member(frame_type, i);
+		ir_type   *entity_type = get_entity_type(member);
 
 		int align = get_type_alignment_bytes(entity_type);
 		if (align > align_all)
@@ -5927,7 +5895,7 @@ static void create_function(entity_t *entity)
 			}
 		}
 
-		set_entity_offset(entity, offset);
+		set_entity_offset(member, offset);
 		offset += get_type_size_bytes(entity_type);
 	}
 	set_type_size_bytes(frame_type, offset);