X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=d27d18a6f1f19a871793a167b08cfcf91f8398c3;hb=e7ba741cdd9599ce05d7989bff60a1c6137ee0b5;hp=d515e3bb0818c787be52b946c4d8ab1e667ab390;hpb=1acb2d4d85e5a1a753692044c17c21843262cd91;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index d515e3bb0..d27d18a6f 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -1,11 +1,28 @@
-/**
- * ABI lowering.
+/*
+ * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
  *
- * @author Sebastian Hack
- * @date   7.3.2005
- * @cvsid  $Id$
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
  */
 
+/**
+ * @file
+ * @brief       Backend ABI implementation.
+ * @author      Sebastian Hack, Michael Beck
+ * @version     $Id$
+ */
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
@@ -13,7 +30,6 @@
 #include "obst.h"
 #include "offset.h"
 
-#include "type.h"
 #include "irgopt.h"
 
 #include "irgraph_t.h"
@@ -28,14 +44,17 @@
 #include "height.h"
 #include "pdeq.h"
 #include "irtools.h"
+#include "raw_bitset.h"
+#include "error.h"
 
 #include "be.h"
 #include "beabi.h"
-#include "bearch.h"
+#include "bearch_t.h"
 #include "benode_t.h"
 #include "belive_t.h"
 #include "besched_t.h"
-#include "beirg.h"
+#include "beirg_t.h"
+#include "bessaconstr.h"
 
 typedef struct _be_abi_call_arg_t {
 	unsigned is_res   : 1;  /**< 1: the call argument is a return value. 0: it's a call parameter. */
@@ -45,9 +64,9 @@ typedef struct _be_abi_call_arg_t {
 	int pos;
 	const arch_register_t *reg;
 	ir_entity *stack_ent;
-	unsigned alignment;
-	unsigned space_before;
-	unsigned space_after;
+	unsigned alignment;     /**< stack alignment */
+	unsigned space_before;  /**< allocate space before */
+	unsigned space_after;   /**< allocate space after */
 } be_abi_call_arg_t;
 
 struct _be_abi_call_t {
@@ -69,35 +88,29 @@ struct _be_abi_irg_t {
 	ir_type              *method_type;  /**< The type of the method of the IRG. */
 
 	ir_node              *init_sp;      /**< The node representing the stack pointer
-									     at the start of the function. */
+	                                         at the start of the function. */
 
 	ir_node              *start_barrier; /**< The barrier of the start block */
 
 	ir_node              *reg_params;   /**< The reg params node. */
 	pmap                 *regs;         /**< A map of all callee-save and ignore regs to
-											their Projs to the RegParams node. */
-
-	pset                 *stack_phis;   /**< The set of all Phi nodes inserted due to
-											stack pointer modifying nodes. */
+	                                         their Projs to the RegParams node. */
 
-	int                  start_block_bias;	/**< The stack bias at the end of the start block. */
+	int                  start_block_bias; /**< The stack bias at the end of the start block. */
 
 	void                 *cb;           /**< ABI Callback self pointer. */
 
 	pmap                 *keep_map;     /**< mapping blocks to keep nodes. */
 	pset                 *ignore_regs;  /**< Additional registers which shall be ignored. */
 
-	arch_irn_handler_t irn_handler;
-	arch_irn_ops_t     irn_ops;
+	ir_node             **calls;        /**< flexible array containing all be_Call nodes */
+
+	arch_register_req_t sp_req;
+	arch_register_req_t sp_cls_req;
+
 	DEBUG_ONLY(firm_dbg_module_t    *dbg;)          /**< The debugging module. */
 };
 
-#define get_abi_from_handler(ptr) firm_container_of(ptr, be_abi_irg_t, irn_handler)
-#define get_abi_from_ops(ptr)     firm_container_of(ptr, be_abi_irg_t, irn_ops)
-
-/* Forward, since be need it in be_abi_introduce(). */
-static const arch_irn_ops_if_t abi_irn_ops;
-static const arch_irn_handler_t abi_irn_handler;
 static heights_t *ir_heights;
 
 /* Flag: if set, try to omit the frame pointer if called by the backend */
@@ -120,6 +133,7 @@ static int be_omit_fp = 1;
 static int cmp_call_arg(const void *a, const void *b, size_t n)
 {
 	const be_abi_call_arg_t *p = a, *q = b;
+	(void) n;
 	return !(p->is_res == q->is_res && p->pos == q->pos);
 }
 
@@ -377,7 +391,8 @@ static INLINE int is_on_stack(be_abi_call_t *call, int pos)
 */
 
 /**
- * Transform a call node.
+ * Transform a call node into a be_Call node.
+ *
  * @param env The ABI environment for the current irg.
  * @param irn The call node.
  * @param curr_sp The stack pointer node to use.
@@ -385,34 +400,38 @@ static INLINE int is_on_stack(be_abi_call_t *call, int pos)
  */
 static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, ir_node *alloca_copy)
 {
-	ir_graph *irg             = env->birg->irg;
-	const arch_isa_t *isa     = env->birg->main_env->arch_env->isa;
-	ir_type *mt               = get_Call_type(irn);
-	ir_node *call_ptr         = get_Call_ptr(irn);
-	int n_params              = get_method_n_params(mt);
-	ir_node *curr_mem         = get_Call_mem(irn);
-	ir_node *bl               = get_nodes_block(irn);
-	pset *results             = pset_new_ptr(8);
-	pset *caller_save         = pset_new_ptr(8);
-	int stack_size            = 0;
-	int stack_dir             = arch_isa_stack_dir(isa);
-	const arch_register_t *sp = arch_isa_sp(isa);
-	be_abi_call_t *call       = be_abi_call_new(sp->reg_class);
-	ir_mode *mach_mode        = sp->reg_class->mode;
-	struct obstack *obst      = &env->obst;
-	int no_alloc              = call->flags.bits.frame_is_setup_on_call;
-
-	ir_node *res_proj = NULL;
-	int curr_res_proj = pn_Call_max;
-	int n_low_args    = 0;
-	int n_pos         = 0;
+	ir_graph *irg              = env->birg->irg;
+	const arch_env_t *arch_env = env->birg->main_env->arch_env;
+	const arch_isa_t *isa      = arch_env->isa;
+	ir_type *mt                = get_Call_type(irn);
+	ir_node *call_ptr          = get_Call_ptr(irn);
+	int n_params               = get_method_n_params(mt);
+	ir_node *curr_mem          = get_Call_mem(irn);
+	ir_node *bl                = get_nodes_block(irn);
+	pset *results              = pset_new_ptr(8);
+	pset *caller_save          = pset_new_ptr(8);
+	pset *states               = pset_new_ptr(2);
+	int stack_size             = 0;
+	int stack_dir              = arch_isa_stack_dir(isa);
+	const arch_register_t *sp  = arch_isa_sp(isa);
+	be_abi_call_t *call        = be_abi_call_new(sp->reg_class);
+	ir_mode *mach_mode         = sp->reg_class->mode;
+	struct obstack *obst       = &env->obst;
+	int no_alloc               = call->flags.bits.frame_is_setup_on_call;
+
+	ir_node *res_proj  = NULL;
+	int curr_res_proj  = pn_Call_max;
+	int n_reg_params   = 0;
+	int n_stack_params = 0;
+	int n_ins;
 
 	ir_node *low_call;
 	ir_node **in;
 	ir_node **res_projs;
+	const arch_register_t *reg;
 	const ir_edge_t *edge;
-	int *low_args;
-	int *pos;
+	int *reg_param_idxs;
+	int *stack_param_idx;
 	int i, n;
 
 	/* Let the isa fill out the abi description for that call node. */
@@ -420,7 +439,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 
 	/* Insert code to put the stack arguments on the stack. */
 	assert(get_Call_n_params(irn) == n_params);
-	for(i = 0; i < n_params; ++i) {
+	for (i = 0; i < n_params; ++i) {
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
 		assert(arg);
 		if (arg->on_stack) {
@@ -430,23 +449,23 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 			stack_size += round_up2(arg_size, arg->alignment);
 			stack_size += round_up2(arg->space_after, arg->alignment);
 			obstack_int_grow(obst, i);
-			n_pos++;
+			++n_stack_params;
 		}
 	}
-	pos = obstack_finish(obst);
+	stack_param_idx = obstack_finish(obst);
 
 	/* Collect all arguments which are passed in registers. */
-	for(i = 0, n = get_Call_n_params(irn); i < n; ++i) {
+	for (i = 0; i < n_params; ++i) {
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
-		if(arg && arg->in_reg) {
+		if (arg && arg->in_reg) {
 			obstack_int_grow(obst, i);
-			n_low_args++;
+			++n_reg_params;
 		}
 	}
-	low_args = obstack_finish(obst);
+	reg_param_idxs = obstack_finish(obst);
 
 	/* If there are some parameters which shall be passed on the stack. */
-	if(n_pos > 0) {
+	if (n_stack_params > 0) {
 		int curr_ofs      = 0;
 		int do_seq        = call->flags.bits.store_args_sequential && !no_alloc;
 
@@ -456,11 +475,11 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		 * direction is downwards.
 		 */
 		if (call->flags.bits.left_to_right ^ (do_seq && stack_dir < 0)) {
-			for (i = 0; i < n_pos >> 1; ++i) {
-				int other  = n_pos - i - 1;
-				int tmp    = pos[i];
-				pos[i]     = pos[other];
-				pos[other] = tmp;
+			for (i = 0; i < n_stack_params >> 1; ++i) {
+				int other  = n_stack_params - i - 1;
+				int tmp    = stack_param_idx[i];
+				stack_param_idx[i]     = stack_param_idx[other];
+				stack_param_idx[other] = tmp;
 			}
 		}
 
@@ -470,23 +489,23 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		 * we allocate as much space on the stack all parameters need, by
 		 * moving the stack pointer along the stack's direction.
 		 */
-		if(stack_dir < 0 && !do_seq && !no_alloc) {
+		if (stack_dir < 0 && !do_seq && !no_alloc) {
 			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size);
-			if(alloca_copy) {
+			if (alloca_copy) {
 				add_irn_dep(curr_sp, alloca_copy);
 				alloca_copy = NULL;
 			}
 		}
 
-		if(!do_seq) {
+		if (! do_seq) {
 			obstack_ptr_grow(obst, get_Call_mem(irn));
 			curr_mem = new_NoMem();
 		} else {
 			curr_mem = get_Call_mem(irn);
 		}
 
-		for(i = 0; i < n_pos; ++i) {
-			int p                  = pos[i];
+		for (i = 0; i < n_stack_params; ++i) {
+			int p                  = stack_param_idx[i];
 			be_abi_call_arg_t *arg = get_call_arg(call, 0, p);
 			ir_node *param         = get_Call_param(irn, p);
 			ir_node *addr          = curr_sp;
@@ -502,7 +521,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 			if (do_seq) {
 				curr_ofs = 0;
 				addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before);
-				if(alloca_copy) {
+				if (alloca_copy) {
 					add_irn_dep(curr_sp, alloca_copy);
 					alloca_copy = NULL;
 				}
@@ -513,7 +532,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 				curr_ofs =  round_up2(curr_ofs, arg->alignment);
 
 				/* Make the expression to compute the argument's offset. */
-				if(curr_ofs > 0) {
+				if (curr_ofs > 0) {
 					ir_mode *constmode = mach_mode;
 					if(mode_is_reference(mach_mode)) {
 						constmode = mode_Is;
@@ -550,9 +569,9 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		in = (ir_node **) obstack_finish(obst);
 
 		/* We need the sync only, if we didn't build the stores sequentially. */
-		if(!do_seq) {
-			if(n_pos >= 1) {
-				curr_mem = new_r_Sync(irg, bl, n_pos + 1, in);
+		if (! do_seq) {
+			if (n_stack_params >= 1) {
+				curr_mem = new_r_Sync(irg, bl, n_stack_params + 1, in);
 			} else {
 				curr_mem = get_Call_mem(irn);
 			}
@@ -561,13 +580,18 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	}
 
 	/* Collect caller save registers */
-	for(i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
+	for (i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
 		int j;
 		const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
-		for(j = 0; j < cls->n_regs; ++j) {
+		for (j = 0; j < cls->n_regs; ++j) {
 			const arch_register_t *reg = arch_register_for_index(cls, j);
-			if(arch_register_type_is(reg, caller_save))
+			if (arch_register_type_is(reg, caller_save)) {
 				pset_insert_ptr(caller_save, (void *) reg);
+			}
+			if (arch_register_type_is(reg, state)) {
+				pset_insert_ptr(caller_save, (void*) reg);
+				pset_insert_ptr(states, (void*) reg);
+			}
 		}
 	}
 
@@ -585,7 +609,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		const ir_edge_t *res_edge;
 		ir_node *irn = get_edge_src_irn(edge);
 
-		if(is_Proj(irn) && get_Proj_proj(irn) == pn_Call_T_result) {
+		if (is_Proj(irn) && get_Proj_proj(irn) == pn_Call_T_result) {
 			res_proj = irn;
 			foreach_out_edge(irn, res_edge) {
 				int proj;
@@ -595,7 +619,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 				assert(is_Proj(res));
 
 				proj = get_Proj_proj(res);
-				arg = get_call_arg(call, 1, proj);
+				arg  = get_call_arg(call, 1, proj);
 
 				/*
 					shift the proj number to the right, since we will drop the
@@ -606,9 +630,9 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 				set_Proj_proj(res, proj);
 				obstack_ptr_grow(obst, res);
 
-				if(proj > curr_res_proj)
+				if (proj > curr_res_proj)
 					curr_res_proj = proj;
-				if(arg->in_reg) {
+				if (arg->in_reg) {
 					pset_remove_ptr(caller_save, arg->reg);
 					//pmap_insert(arg_regs, arg->reg, INT_TO_PTR(proj + 1))
 				}
@@ -621,22 +645,37 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	res_projs = obstack_finish(obst);
 
 	/* make the back end call node and set its register requirements. */
-	for(i = 0; i < n_low_args; ++i)
-		obstack_ptr_grow(obst, get_Call_param(irn, low_args[i]));
+	for (i = 0; i < n_reg_params; ++i) {
+		obstack_ptr_grow(obst, get_Call_param(irn, reg_param_idxs[i]));
+	}
+	foreach_pset(states, reg) {
+		const arch_register_class_t *cls = arch_register_get_class(reg);
+#if 0
+		ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
+		ir_fprintf(stderr, "Adding %+F\n", regnode);
+#endif
+		ir_node *regnode = new_rd_Unknown(irg, arch_register_class_mode(cls));
+		obstack_ptr_grow(obst, regnode);
+	}
+	n_ins = n_reg_params + pset_count(states);
 
 	in = obstack_finish(obst);
 
-	if(env->call->flags.bits.call_has_imm && get_irn_opcode(call_ptr) == iro_SymConst) {
-		low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem, curr_sp, curr_sp,
-		                       curr_res_proj + pset_count(caller_save), n_low_args, in,
-		                       get_Call_type(irn));
+	if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
+		/* direct call */
+		low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem,
+		                       curr_sp, curr_sp,
+		                       curr_res_proj + pset_count(caller_save), n_ins,
+		                       in, get_Call_type(irn));
 		be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
+	} else {
+		/* indirect call */
+		low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem,
+		                       curr_sp, call_ptr,
+		                       curr_res_proj + pset_count(caller_save),
+		                       n_ins, in, get_Call_type(irn));
 	}
-
-	else
-		low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem, curr_sp, call_ptr,
-		                       curr_res_proj + pset_count(caller_save), n_low_args, in,
-		                       get_Call_type(irn));
+	ARR_APP1(ir_node *, env->calls, low_call);
 
 	/*
 		Set the register class of the call address to
@@ -644,35 +683,37 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	*/
 	be_node_set_reg_class(low_call, be_pos_Call_ptr, call->cls_addr);
 
-	/* Set input requirement for stack pointer. */
-	be_node_set_reg_class(low_call, be_pos_Call_sp, arch_get_irn_reg_class(isa->main_env->arch_env, curr_sp, -1));
-
 	DBG((env->dbg, LEVEL_3, "\tcreated backend call %+F\n", low_call));
 
 	/* Set the register classes and constraints of the Call parameters. */
-	for(i = 0; i < n_low_args; ++i) {
-		int index = low_args[i];
+	for (i = 0; i < n_reg_params; ++i) {
+		int index = reg_param_idxs[i];
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, index);
 		assert(arg->reg != NULL);
 
-		be_set_constr_single_reg(low_call, be_pos_Call_first_arg + index, arg->reg);
+		be_set_constr_single_reg(low_call, be_pos_Call_first_arg + i, arg->reg);
 	}
 
 	/* Set the register constraints of the results. */
 	for (i = 0; res_projs[i]; ++i) {
-		ir_node *irn = res_projs[i];
-		int     proj = get_Proj_proj(irn);
+		int pn = get_Proj_proj(res_projs[i]);
 
 		/* Correct Proj number since it has been adjusted! (see above) */
-		const be_abi_call_arg_t *arg = get_call_arg(call, 1, proj - pn_Call_max);
+		const be_abi_call_arg_t *arg = get_call_arg(call, 1, pn - pn_Call_max);
 
+		/* Matze: we need the information about the real mode for later
+		 * transforms (signed/unsigend compares, stores...), so leave the fixup
+		 * for the backend transform phase... */
+#if 0
 		/* correct mode */
 		const arch_register_class_t *cls = arch_register_get_class(arg->reg);
 		ir_mode *mode = arch_register_class_mode(cls);
 		set_irn_mode(irn, mode);
+#endif
 
 		assert(arg->in_reg);
-		be_set_constr_single_reg(low_call, BE_OUT_POS(proj), arg->reg);
+		be_set_constr_single_reg(low_call, BE_OUT_POS(pn), arg->reg);
+		arch_set_irn_register(arch_env, res_projs[i], arg->reg);
 	}
 	obstack_free(obst, in);
 	exchange(irn, low_call);
@@ -682,7 +723,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		set_Proj_pred(res_projs[i], low_call);
 
 	/* set the now unnecessary projT to bad */
-	if(res_proj != NULL) {
+	if (res_proj != NULL) {
 		be_kill_node(res_proj);
 	}
 
@@ -721,7 +762,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	}
 
 	/* Clean up the stack. */
-	if(stack_size > 0) {
+	if (stack_size > 0) {
 		ir_node *mem_proj = NULL;
 
 		foreach_out_edge(low_call, edge) {
@@ -732,16 +773,16 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 			}
 		}
 
-		if(!mem_proj) {
+		if (! mem_proj) {
 			mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_Call_M);
 			keep_alive(mem_proj);
 		}
 
 		 /* Clean up the stack frame if we allocated it */
-		if(!no_alloc) {
+		if (! no_alloc) {
 			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size);
 			add_irn_dep(curr_sp, mem_proj);
-			if(alloca_copy) {
+			if (alloca_copy) {
 				add_irn_dep(curr_sp, alloca_copy);
 				alloca_copy = NULL;
 			}
@@ -749,13 +790,39 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	}
 
 	be_abi_call_free(call);
-	obstack_free(obst, pos);
+	obstack_free(obst, stack_param_idx);
 	del_pset(results);
+	del_pset(states);
 	del_pset(caller_save);
 
 	return curr_sp;
 }
 
+/**
+ * Adjust the size of a node representing a stack alloc or free for the minimum stack alignment.
+ *
+ * @param alignment  the minimum stack alignment
+ * @param size       the node containing the non-aligned size
+ * @param irg        the irg where new nodes are allocated on
+ * @param irg        the block where new nodes are allocated on
+ * @param dbg        debug info for new nodes
+ *
+ * @return a node representing the aligned size
+ */
+static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size, ir_graph *irg, ir_node *block, dbg_info *dbg) {
+	if (stack_alignment > 1) {
+		ir_mode *mode = get_irn_mode(size);
+		tarval *tv = new_tarval_from_long(stack_alignment-1, mode);
+		ir_node *mask = new_r_Const(irg, block, mode, tv);
+
+		size = new_rd_Add(dbg, irg, block, size, mask, mode);
+
+		tv   = new_tarval_from_long(-(long)stack_alignment, mode);
+		mask = new_r_Const(irg, block, mode, tv);
+		size = new_rd_And(dbg, irg, block, size, mask, mode);
+	}
+	return size;
+}
 /**
  * Adjust an alloca.
  * The alloca is transformed into a back end alloca node and connected to the stack nodes.
@@ -767,13 +834,11 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 	ir_node *alloc_mem;
 	ir_node *alloc_res;
 	ir_type *type;
+	dbg_info *dbg;
 
 	const ir_edge_t *edge;
-	ir_node *new_alloc;
-	ir_node *size;
-	ir_node *addr;
-	ir_node *copy;
-	ir_node *ins[2];
+	ir_node *new_alloc, *size, *addr, *copy, *ins[2];
+	unsigned stack_alignment;
 
 	if (get_Alloc_where(alloc) != stack_alloc) {
 		assert(0);
@@ -810,11 +875,13 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 		return curr_sp;
 	}
 
+	dbg = get_irn_dbg_info(alloc);
+
 	/* we might need to multiply the size with the element size */
 	if(type != get_unknown_type() && get_type_size_bytes(type) != 1) {
 		tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
-		ir_node *cnst = new_rd_Const(NULL, irg, block, mode_Iu, tv);
-		ir_node *mul = new_rd_Mul(NULL, irg, block, get_Alloc_size(alloc),
+		ir_node *cnst = new_rd_Const(dbg, irg, block, mode_Iu, tv);
+		ir_node *mul = new_rd_Mul(dbg, irg, block, get_Alloc_size(alloc),
 		                          cnst, mode_Iu);
 		size = mul;
 	} else {
@@ -824,7 +891,13 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 	/* The stack pointer will be modified in an unknown manner.
 	   We cannot omit it. */
 	env->call->flags.bits.try_omit_fp = 0;
+
+	/* FIXME: size must be here round up for the stack alignment, but
+	   this must be transmitted from the backend. */
+	stack_alignment = 4;
+	size = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
 	new_alloc = be_new_AddSP(env->isa->sp, irg, block, curr_sp, size);
+	set_irn_dbg_info(new_alloc, dbg);
 
 	if(alloc_mem != NULL) {
 		ir_node *addsp_mem;
@@ -832,8 +905,8 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 
 		addsp_mem = new_r_Proj(irg, block, new_alloc, mode_M, pn_be_AddSP_M);
 
-		// We need to sync the output mem of the AddSP with the input mem
-		// edge into the alloc node
+		/* We need to sync the output mem of the AddSP with the input mem
+		   edge into the alloc node. */
 		ins[0] = get_Alloc_mem(alloc);
 		ins[1] = addsp_mem;
 		sync = new_r_Sync(irg, block, 2, ins);
@@ -871,8 +944,12 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
 {
 	ir_node *block;
 	ir_graph *irg;
-	ir_node *addsp, *mem, *res, *size;
+	ir_node *subsp, *mem, *res, *size, *sync;
 	ir_type *type;
+	ir_node *in[2];
+	ir_mode *sp_mode;
+	unsigned stack_alignment;
+	dbg_info *dbg;
 
 	if (get_Free_where(free) != stack_alloc) {
 		assert(0);
@@ -882,27 +959,44 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
 	block = get_nodes_block(free);
 	irg = get_irn_irg(block);
 	type = get_Free_type(free);
+	sp_mode = env->isa->sp->reg_class->mode;
+	dbg = get_irn_dbg_info(free);
 
 	/* we might need to multiply the size with the element size */
 	if(type != get_unknown_type() && get_type_size_bytes(type) != 1) {
 		tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
-		ir_node *cnst = new_rd_Const(NULL, irg, block, mode_Iu, tv);
-		ir_node *mul = new_rd_Mul(NULL, irg, block, get_Free_size(free),
+		ir_node *cnst = new_rd_Const(dbg, irg, block, mode_Iu, tv);
+		ir_node *mul = new_rd_Mul(dbg, irg, block, get_Free_size(free),
 		                          cnst, mode_Iu);
 		size = mul;
 	} else {
 		size = get_Free_size(free);
 	}
 
+	/* FIXME: size must be here round up for the stack alignment, but
+	   this must be transmitted from the backend. */
+	stack_alignment = 4;
+	size = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
+
 	/* The stack pointer will be modified in an unknown manner.
 	   We cannot omit it. */
 	env->call->flags.bits.try_omit_fp = 0;
-	addsp = be_new_SubSP(env->isa->sp, irg, block, curr_sp, size);
+	subsp = be_new_SubSP(env->isa->sp, irg, block, curr_sp, size);
+	set_irn_dbg_info(subsp, dbg);
+
+	mem = new_r_Proj(irg, block, subsp, mode_M, pn_be_SubSP_M);
+	res = new_r_Proj(irg, block, subsp, sp_mode, pn_be_SubSP_res);
 
-	mem = new_r_Proj(irg, block, addsp, mode_M, pn_be_SubSP_M);
-	res = new_r_Proj(irg, block, addsp, mode_P_data, pn_be_SubSP_res);
+	/* we need to sync the memory */
+	in[0] = get_Free_mem(free);
+	in[1] = mem;
+	sync = new_r_Sync(irg, block, 2, in);
 
-	exchange(free, mem);
+	/* and make the AddSP dependent on the former memory */
+	add_irn_dep(subsp, get_Free_mem(free));
+
+	/* kill the free */
+	exchange(free, sync);
 	curr_sp = res;
 
 	return curr_sp;
@@ -947,15 +1041,12 @@ static int check_dependence(ir_node *curr, ir_node *tgt, ir_node *bl)
  */
 static int dependent_on(ir_node *n1, ir_node *n2)
 {
-	ir_node *bl   = get_nodes_block(n1);
-
-	assert(bl == get_nodes_block(n2));
+	assert(get_nodes_block(n1) == get_nodes_block(n2));
 
 	return heights_reachable_in_block(ir_heights, n1, n2);
-	//return check_dependence(n1, n2, bl);
 }
 
-static int cmp_call_dependecy(const void *c1, const void *c2)
+static int cmp_call_dependency(const void *c1, const void *c2)
 {
 	ir_node *n1 = *(ir_node **) c1;
 	ir_node *n2 = *(ir_node **) c2;
@@ -1024,7 +1115,7 @@ static void process_calls_in_block(ir_node *bl, void *data)
 		nodes = obstack_finish(&env->obst);
 
 		/* order the call nodes according to data dependency */
-		qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependecy);
+		qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependency);
 
 		for(i = n - 1; i >= 0; --i) {
 			ir_node *irn = nodes[i];
@@ -1041,6 +1132,7 @@ static void process_calls_in_block(ir_node *bl, void *data)
 				curr_sp = adjust_free(env, irn, curr_sp);
 				break;
 			default:
+				panic("invalid call");
 				break;
 			}
 		}
@@ -1048,9 +1140,12 @@ static void process_calls_in_block(ir_node *bl, void *data)
 		obstack_free(&env->obst, nodes);
 
 		/* Keep the last stack state in the block by tying it to Keep node */
-		nodes[0] = curr_sp;
-		keep     = be_new_Keep(env->isa->sp->reg_class, get_irn_irg(bl), bl, 1, nodes);
-		pmap_insert(env->keep_map, bl, keep);
+		if(curr_sp != env->init_sp) {
+			nodes[0] = curr_sp;
+			keep     = be_new_Keep(env->isa->sp->reg_class, get_irn_irg(bl),
+			                       bl, 1, nodes);
+			pmap_insert(env->keep_map, bl, keep);
+		}
 	}
 
 	set_irn_link(bl, curr_sp);
@@ -1381,11 +1476,9 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i
 	*/
 	stack = be_abi_reg_map_get(env->regs, isa->sp);
 	if (keep) {
-		ir_node *bad = new_r_Bad(env->birg->irg);
 		stack = get_irn_n(keep, 0);
-		set_nodes_block(keep, bad);
-		set_irn_n(keep, 0, bad);
-		// exchange(keep, new_r_Bad(env->birg->irg));
+		be_kill_node(keep);
+		remove_End_keepalive(get_irg_end(env->birg->irg), keep);
 	}
 
 	/* Insert results for Return into the register map. */
@@ -1462,14 +1555,15 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i
 typedef struct lower_frame_sels_env_t {
 	be_abi_irg_t *env;
 	ir_entity    *value_param_list;  /**< the list of all value param entities */
+	ir_entity    *value_param_tail;  /**< the tail of the list of all value param entities */
 } lower_frame_sels_env_t;
 
 /**
  * Walker: Replaces Sels of frame type and
  * value param type entities by FrameAddress.
+ * Links all used entities.
  */
-static void lower_frame_sels_walker(ir_node *irn, void *data)
-{
+static void lower_frame_sels_walker(ir_node *irn, void *data) {
 	lower_frame_sels_env_t *ctx = data;
 
 	if (is_Sel(irn)) {
@@ -1487,10 +1581,13 @@ static void lower_frame_sels_walker(ir_node *irn, void *data)
 			nw = be_new_FrameAddr(env->isa->sp->reg_class, irg, bl, frame, ent);
 			exchange(irn, nw);
 
-			/* check, if it's a param sel and if have not seen this entity immediatly before */
-			if (ptr == param_base && ctx->value_param_list != ent) {
+			/* check, if it's a param sel and if have not seen this entity before */
+			if (ptr == param_base &&
+					ent != ctx->value_param_tail &&
+					get_entity_link(ent) == NULL) {
 				set_entity_link(ent, ctx->value_param_list);
 				ctx->value_param_list = ent;
+				if (ctx->value_param_tail == NULL) ctx->value_param_tail = ent;
 			}
 		}
 	}
@@ -1645,7 +1742,9 @@ static void modify_irg(be_abi_irg_t *env)
 	ir_graph *irg             = env->birg->irg;
 	ir_node *bl               = get_irg_start_block(irg);
 	ir_node *end              = get_irg_end_block(irg);
-	ir_node *mem              = get_irg_initial_mem(irg);
+	ir_node *old_mem          = get_irg_initial_mem(irg);
+	ir_node *new_mem_proj;
+	ir_node *mem;
 	ir_type *method_type      = get_entity_type(get_irg_entity(irg));
 	pset *dont_save           = pset_new_ptr(8);
 
@@ -1661,7 +1760,7 @@ static void modify_irg(be_abi_irg_t *env)
 	ir_node *arg_tuple;
 	ir_node *value_param_base;
 	const ir_edge_t *edge;
-	ir_type *arg_type, *bet_type;
+	ir_type *arg_type, *bet_type, *tp;
 	lower_frame_sels_env_t ctx;
 	ir_entity **param_map;
 
@@ -1670,9 +1769,18 @@ static void modify_irg(be_abi_irg_t *env)
 
 	DBG((dbg, LEVEL_1, "introducing abi on %+F\n", irg));
 
+	/* set the links of all frame entities to NULL, we use it
+	   to detect if an entity is already linked in the value_param_list */
+	tp = get_method_value_param_type(method_type);
+	if (tp != NULL) {
+		for (i = get_struct_n_members(tp) - 1; i >= 0; --i)
+			set_entity_link(get_struct_member(tp, i), NULL);
+	}
+
 	/* Convert the Sel nodes in the irg to frame load/store/addr nodes. */
 	ctx.env              = env;
 	ctx.value_param_list = NULL;
+	ctx.value_param_tail = NULL;
 	irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
 
 	/* value_param_base anchor is not needed anymore now */
@@ -1732,8 +1840,10 @@ static void modify_irg(be_abi_irg_t *env)
 		const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
 		for(j = 0; j < cls->n_regs; ++j) {
 			const arch_register_t *reg = &cls->regs[j];
-			if(arch_register_type_is(reg, callee_save))
+			if(arch_register_type_is(reg, callee_save) ||
+					arch_register_type_is(reg, state)) {
 				pmap_insert(env->regs, (void *) reg, NULL);
+			}
 		}
 	}
 
@@ -1784,24 +1894,35 @@ static void modify_irg(be_abi_irg_t *env)
 	}
 	obstack_free(&env->obst, rm);
 
+	/* create a new initial memory proj */
+	assert(is_Proj(old_mem));
+	new_mem_proj = new_r_Proj(irg, get_nodes_block(old_mem),
+	                          new_r_Unknown(irg, mode_T), mode_M,
+	                          get_Proj_proj(old_mem));
+	mem = new_mem_proj;
+
 	/* Generate the Prologue */
 	fp_reg  = call->cb->prologue(env->cb, &mem, env->regs);
 
 	/* do the stack allocation BEFORE the barrier, or spill code
 	   might be added before it */
-	env->init_sp  = be_abi_reg_map_get(env->regs, sp);
+	env->init_sp = be_abi_reg_map_get(env->regs, sp);
 	env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND);
 	be_abi_reg_map_set(env->regs, sp, env->init_sp);
 
 	env->start_barrier = barrier = create_barrier(env, bl, &mem, env->regs, 0);
 
-	env->init_sp  = be_abi_reg_map_get(env->regs, sp);
+	env->init_sp = be_abi_reg_map_get(env->regs, sp);
 	arch_set_irn_register(env->birg->main_env->arch_env, env->init_sp, sp);
 
 	frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
 	set_irg_frame(irg, frame_pointer);
 	pset_insert_ptr(env->ignore_regs, fp_reg);
 
+	/* rewire old mem users to new mem */
+	set_Proj_pred(new_mem_proj, get_Proj_pred(old_mem));
+	exchange(old_mem, mem);
+
 	set_irg_initial_mem(irg, mem);
 
 	/* Now, introduce stack param nodes for all parameters passed on the stack */
@@ -1812,13 +1933,14 @@ static void modify_irg(be_abi_irg_t *env)
 		if(arg_proj != NULL) {
 			be_abi_call_arg_t *arg;
 			ir_type *param_type;
-			int nr = get_Proj_proj(arg_proj);
+			int     nr = get_Proj_proj(arg_proj);
+			ir_mode *mode;
 
 			nr         = MIN(nr, n_params);
 			arg        = get_call_arg(call, 0, nr);
 			param_type = get_method_param_type(method_type, nr);
 
-			if(arg->in_reg) {
+			if (arg->in_reg) {
 				repl = pmap_get(env->regs, (void *) arg->reg);
 			}
 
@@ -1831,14 +1953,21 @@ static void modify_irg(be_abi_irg_t *env)
 				}
 
 				/* The stack parameter is not primitive (it is a struct or array),
-				we thus will create a node representing the parameter's address
-				on the stack. */
+				   we thus will create a node representing the parameter's address
+				   on the stack. */
 				else {
 					repl = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
 				}
 			}
 
 			assert(repl != NULL);
+
+			/* Beware: the mode of the register parameters is always the mode of the register class
+			   which may be wrong. Add Conv's then. */
+			mode = get_irn_mode(args[i]);
+			if (mode != get_irn_mode(repl)) {
+				repl = new_r_Conv(irg, get_irn_n(repl, -1), repl, mode);
+			}
 			exchange(args[i], repl);
 		}
 	}
@@ -1857,7 +1986,7 @@ static void modify_irg(be_abi_irg_t *env)
 			exchange(irn, ret);
 		}
 	}
-	/* if we have endless loops here, n might be <= 0. Do NOT create a be_Return than,
+	/* if we have endless loops here, n might be <= 0. Do NOT create a be_Return then,
 	   the code is dead and will never be executed. */
 
 	del_pset(dont_save);
@@ -1868,6 +1997,46 @@ static void modify_irg(be_abi_irg_t *env)
 	irg_block_walk_graph(irg, fix_start_block, NULL, &temp);
 }
 
+/** Fix the state inputs of calls that still hang on unknowns */
+static
+void fix_call_state_inputs(be_abi_irg_t *env)
+{
+	const arch_isa_t *isa = env->isa;
+	int i, n, n_states;
+	arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0);
+
+	/* Collect caller save registers */
+	n = arch_isa_get_n_reg_class(isa);
+	for(i = 0; i < n; ++i) {
+		int j;
+		const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
+		for(j = 0; j < cls->n_regs; ++j) {
+			const arch_register_t *reg = arch_register_for_index(cls, j);
+			if(arch_register_type_is(reg, state)) {
+				ARR_APP1(arch_register_t*, stateregs, (arch_register_t *)reg);
+			}
+		}
+	}
+
+	n = ARR_LEN(env->calls);
+	n_states = ARR_LEN(stateregs);
+	for(i = 0; i < n; ++i) {
+		int s, arity;
+		ir_node *call = env->calls[i];
+
+		arity = get_irn_arity(call);
+
+		/* the statereg inputs are the last n inputs of the calls */
+		for(s = 0; s < n_states; ++s) {
+			int inp = arity - n_states + s;
+			const arch_register_t *reg = stateregs[s];
+			ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
+
+			set_irn_n(call, inp, regnode);
+		}
+	}
+}
+
 be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 {
 	be_abi_irg_t *env  = xmalloc(sizeof(env[0]));
@@ -1877,21 +2046,31 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	pmap_entry *ent;
 	ir_node *dummy;
 	optimization_state_t state;
+	unsigned *limited_bitset;
 
 	be_omit_fp = birg->main_env->options->omit_fp;
 
 	obstack_init(&env->obst);
 
-	env->isa           = birg->main_env->arch_env->isa;
-	env->method_type   = get_entity_type(get_irg_entity(irg));
-	env->call          = be_abi_call_new(env->isa->sp->reg_class);
+	env->isa         = birg->main_env->arch_env->isa;
+	env->method_type = get_entity_type(get_irg_entity(irg));
+	env->call        = be_abi_call_new(env->isa->sp->reg_class);
 	arch_isa_get_call_abi(env->isa, env->method_type, env->call);
 
-	env->ignore_regs      = pset_new_ptr_default();
-	env->keep_map         = pmap_create();
-	env->dce_survivor     = new_survive_dce();
-	env->birg             = birg;
-	env->stack_phis       = pset_new_ptr(16);
+	env->ignore_regs  = pset_new_ptr_default();
+	env->keep_map     = pmap_create();
+	env->dce_survivor = new_survive_dce();
+	env->birg         = birg;
+
+	env->sp_req.type    = arch_register_req_type_limited;
+	env->sp_req.cls     = arch_register_get_class(env->isa->sp);
+	limited_bitset      = rbitset_obstack_alloc(&env->obst, env->sp_req.cls->n_regs);
+	rbitset_set(limited_bitset, arch_register_get_index(env->isa->sp));
+	env->sp_req.limited = limited_bitset;
+
+	env->sp_cls_req.type  = arch_register_req_type_normal;
+	env->sp_cls_req.cls   = arch_register_get_class(env->isa->sp);
+
 	/* Beware: later we replace this node by the real one, ensure it is not CSE'd
 	   to another Unknown or the stack pointer gets used */
 	save_optimization_state(&state);
@@ -1900,8 +2079,7 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	restore_optimization_state(&state);
 	FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
 
-	memcpy(&env->irn_handler, &abi_irn_handler, sizeof(abi_irn_handler));
-	env->irn_ops.impl = &abi_irn_ops;
+	env->calls = NEW_ARR_F(ir_node*, 0);
 
 	/* Lower all call nodes in the IRG. */
 	process_calls(env);
@@ -1915,19 +2093,24 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	/* Process the IRG */
 	modify_irg(env);
 
+	/* fix call inputs for state registers */
+	fix_call_state_inputs(env);
+
 	/* We don't need the keep map anymore. */
 	pmap_destroy(env->keep_map);
 
+	/* calls array is not needed anymore */
+	DEL_ARR_F(env->calls);
+
 	/* reroute the stack origin of the calls to the true stack origin. */
 	exchange(dummy, env->init_sp);
 	exchange(old_frame, get_irg_frame(irg));
 
 	/* Make some important node pointers survive the dead node elimination. */
 	survive_dce_register_irn(env->dce_survivor, &env->init_sp);
-	pmap_foreach(env->regs, ent)
+	pmap_foreach(env->regs, ent) {
 		survive_dce_register_irn(env->dce_survivor, (ir_node **) &ent->value);
-
-	arch_env_push_irn_handler(env->birg->main_env->arch_env, &env->irn_handler);
+	}
 
 	env->call->cb->done(env->cb);
 	env->cb = NULL;
@@ -1936,12 +2119,11 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 
 void be_abi_free(be_abi_irg_t *env)
 {
+	be_abi_call_free(env->call);
 	free_survive_dce(env->dce_survivor);
-	del_pset(env->stack_phis);
 	del_pset(env->ignore_regs);
 	pmap_destroy(env->regs);
 	obstack_free(&env->obst, NULL);
-	arch_env_pop_irn_handler(env->birg->main_env->arch_env);
 	free(env);
 }
 
@@ -1969,46 +2151,79 @@ const be_stack_layout_t *be_abi_get_stack_layout(const be_abi_irg_t *abi) {
 
 */
 
-struct fix_stack_walker_info {
-	nodeset *nodes;
-	const arch_env_t *aenv;
-};
+typedef ir_node **node_array;
+
+typedef struct fix_stack_walker_env_t {
+	node_array sp_nodes;
+	const arch_env_t *arch_env;
+} fix_stack_walker_env_t;
 
 /**
  * Walker. Collect all stack modifying nodes.
  */
-static void collect_stack_nodes_walker(ir_node *irn, void *data)
+static void collect_stack_nodes_walker(ir_node *node, void *data)
 {
-	struct fix_stack_walker_info *info = data;
+	fix_stack_walker_env_t *env = data;
 
-	if (is_Block(irn))
-		return;
-
-	if (arch_irn_is(info->aenv, irn, modify_sp)) {
-		assert(get_irn_mode(irn) != mode_M && get_irn_mode(irn) != mode_T);
-		pset_insert_ptr(info->nodes, irn);
+	if (arch_irn_is(env->arch_env, node, modify_sp)) {
+		assert(get_irn_mode(node) != mode_M && get_irn_mode(node) != mode_T);
+		ARR_APP1(ir_node*, env->sp_nodes, node);
 	}
 }
 
-void be_abi_fix_stack_nodes(be_abi_irg_t *env, be_lv_t *lv)
+void be_abi_fix_stack_nodes(be_abi_irg_t *env)
 {
-	pset *stack_nodes = pset_new_ptr(16);
-	struct fix_stack_walker_info info;
-	int collect_phis;
+	be_ssa_construction_env_t senv;
+	int i, len;
+	ir_node **phis;
+	be_irg_t *birg = env->birg;
+	be_lv_t *lv = be_get_birg_liveness(birg);
+	fix_stack_walker_env_t walker_env;
+	arch_isa_t *isa;
+
+	walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0);
+	walker_env.arch_env = birg->main_env->arch_env;
+	isa = walker_env.arch_env->isa;
+
+	irg_walk_graph(birg->irg, collect_stack_nodes_walker, NULL, &walker_env);
+
+	/* nothing to be done if we didn't find any node, in fact we mustn't
+	 * continue, as for endless loops incsp might have had no users and is bad
+	 * now.
+	 */
+	len = ARR_LEN(walker_env.sp_nodes);
+	if(len == 0) {
+		DEL_ARR_F(walker_env.sp_nodes);
+		return;
+	}
 
-	info.nodes = stack_nodes;
-	info.aenv  = env->birg->main_env->arch_env;
+	be_ssa_construction_init(&senv, birg);
+	be_ssa_construction_add_copies(&senv, walker_env.sp_nodes,
+                                   ARR_LEN(walker_env.sp_nodes));
+	be_ssa_construction_fix_users_array(&senv, walker_env.sp_nodes,
+	                              ARR_LEN(walker_env.sp_nodes));
 
-	be_assure_dom_front(env->birg);
+	if(lv != NULL) {
+		len = ARR_LEN(walker_env.sp_nodes);
+		for(i = 0; i < len; ++i) {
+			be_liveness_update(lv, walker_env.sp_nodes[i]);
+		}
+		be_ssa_construction_update_liveness_phis(&senv, lv);
+	}
 
+	phis = be_ssa_construction_get_new_phis(&senv);
+
+	/* set register requirements for stack phis */
+	len = ARR_LEN(phis);
+	for(i = 0; i < len; ++i) {
+		ir_node *phi = phis[i];
+		be_set_phi_reg_req(walker_env.arch_env, phi, &env->sp_req);
+		be_set_phi_flags(walker_env.arch_env, phi, arch_irn_flags_ignore | arch_irn_flags_modify_sp);
+		arch_set_irn_register(walker_env.arch_env, phi, env->isa->sp);
+	}
+	be_ssa_construction_destroy(&senv);
 
-	irg_walk_graph(env->birg->irg, collect_stack_nodes_walker, NULL, &info);
-	pset_insert_ptr(stack_nodes, env->init_sp);
-	collect_phis = 1;
-	if (env->call->cb->collect_stack_phis)
-		collect_phis = env->call->cb->collect_stack_phis(env->cb);
-	be_ssa_constr_set_phis(env->birg->dom_front, lv, stack_nodes, collect_phis ? env->stack_phis : NULL);
-	del_pset(stack_nodes);
+	DEL_ARR_F(walker_env.sp_nodes);
 }
 
 static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
@@ -2018,6 +2233,7 @@ static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
 	ir_node *irn;
 
 	sched_foreach(bl, irn) {
+		int ofs;
 
 		/*
 		   Check, if the node relates to an entity on the stack frame.
@@ -2031,12 +2247,12 @@ static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
 			DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n", ent, offset, bias));
 		}
 
-		/*
-		   If the node modifies the stack pointer by a constant offset,
-		   record that in the bias.
-		 */
-		if(arch_irn_is(arch_env, irn, modify_sp)) {
-			int ofs = arch_get_sp_bias(arch_env, irn);
+		if(omit_fp || be_is_IncSP(irn)) {
+			/*
+			 * If the node modifies the stack pointer by a constant offset,
+			 * record that in the bias.
+			 */
+			ofs = arch_get_sp_bias(arch_env, irn);
 
 			if(be_is_IncSP(irn)) {
 				if(ofs == BE_STACK_FRAME_SIZE_EXPAND) {
@@ -2112,119 +2328,6 @@ ir_node *be_abi_get_start_barrier(be_abi_irg_t *abi)
 	return abi->start_barrier;
 }
 
-/*
-  _____ _____  _   _   _    _                 _ _
- |_   _|  __ \| \ | | | |  | |               | | |
-   | | | |__) |  \| | | |__| | __ _ _ __   __| | | ___ _ __
-   | | |  _  /| . ` | |  __  |/ _` | '_ \ / _` | |/ _ \ '__|
-  _| |_| | \ \| |\  | | |  | | (_| | | | | (_| | |  __/ |
- |_____|_|  \_\_| \_| |_|  |_|\__,_|_| |_|\__,_|_|\___|_|
-
-  for Phi nodes which are created due to stack modifying nodes
-  such as IncSP, AddSP and SetSP.
-
-  These Phis are always to be ignored by the reg alloc and are
-  fixed on the SP register of the ISA.
-*/
-
-static const void *abi_get_irn_ops(const arch_irn_handler_t *handler, const ir_node *irn)
-{
-	const be_abi_irg_t *abi = get_abi_from_handler(handler);
-	const void *res = NULL;
-
-	if(is_Phi(irn) && pset_find_ptr(abi->stack_phis, (void *) irn))
-		res = &abi->irn_ops;
-
-	return res;
-}
-
-static void be_abi_limited(void *data, bitset_t *bs)
-{
-	be_abi_irg_t *abi = data;
-	bitset_clear_all(bs);
-	bitset_set(bs, abi->isa->sp->index);
-}
-
-static const arch_register_req_t *abi_get_irn_reg_req(const void *self, arch_register_req_t *req, const ir_node *irn, int pos)
-{
-	be_abi_irg_t *abi          = get_abi_from_ops(self);
-	const arch_register_t *reg = abi->isa->sp;
-
-	memset(req, 0, sizeof(req[0]));
-
-	if(pos == BE_OUT_POS(0)) {
-		req->cls         = reg->reg_class;
-		req->type        = arch_register_req_type_limited;
-		req->limited     = be_abi_limited;
-		req->limited_env = abi;
-	}
-
-	else if(pos >= 0 && pos < get_irn_arity(irn)) {
-		req->cls  = reg->reg_class;
-		req->type = arch_register_req_type_normal;
-	}
-
-	return req;
-}
-
-static void abi_set_irn_reg(const void *self, ir_node *irn, const arch_register_t *reg)
-{
-}
-
-static const arch_register_t *abi_get_irn_reg(const void *self, const ir_node *irn)
-{
-	const be_abi_irg_t *abi = get_abi_from_ops(self);
-	return abi->isa->sp;
-}
-
-static arch_irn_class_t abi_classify(const void *_self, const ir_node *irn)
-{
-	return arch_irn_class_normal;
-}
-
-static arch_irn_flags_t abi_get_flags(const void *_self, const ir_node *irn)
-{
-	return arch_irn_flags_ignore | arch_irn_flags_modify_sp;
-}
-
-static ir_entity *abi_get_frame_entity(const void *_self, const ir_node *irn)
-{
-	return NULL;
-}
-
-static void abi_set_frame_entity(const void *_self, ir_node *irn, ir_entity *ent)
-{
-}
-
-static void abi_set_frame_offset(const void *_self, ir_node *irn, int bias)
-{
-}
-
-static int abi_get_sp_bias(const void *self, const ir_node *irn)
-{
-	return 0;
-}
-
-static const arch_irn_ops_if_t abi_irn_ops = {
-	abi_get_irn_reg_req,
-	abi_set_irn_reg,
-	abi_get_irn_reg,
-	abi_classify,
-	abi_get_flags,
-	abi_get_frame_entity,
-	abi_set_frame_entity,
-	abi_set_frame_offset,
-	abi_get_sp_bias,
-	NULL,    /* get_inverse             */
-	NULL,    /* get_op_estimated_cost   */
-	NULL,    /* possible_memory_operand */
-	NULL,    /* perform_memory_operand  */
-};
-
-static const arch_irn_handler_t abi_irn_handler = {
-	abi_get_irn_ops
-};
-
 /**
  * Returns non-zero if the ABI has omitted the frame pointer in
  * the current graph.