X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=d6c0bbdb5c784b3761402ec0dc54db6ccdec5d43;hb=89dc24503c04139bb05504059b291d6d89f99661;hp=d27d18a6f1f19a871793a167b08cfcf91f8398c3;hpb=7bdb3ff422f6fee6970ebb1eb895f47b9c7661e5;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index d27d18a6f..d6c0bbdb5 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -61,16 +61,18 @@ typedef struct _be_abi_call_arg_t {
 	unsigned in_reg   : 1;  /**< 1: this argument is transmitted in registers. */
 	unsigned on_stack : 1;	/**< 1: this argument is transmitted on the stack. */
 
-	int pos;
+	int                    pos;
 	const arch_register_t *reg;
-	ir_entity *stack_ent;
-	unsigned alignment;     /**< stack alignment */
-	unsigned space_before;  /**< allocate space before */
-	unsigned space_after;   /**< allocate space after */
+	ir_entity             *stack_ent;
+	ir_mode               *load_mode;
+	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 {
-	be_abi_call_flags_t         flags;
+	be_abi_call_flags_t          flags;
+	int                          pop;
 	const be_abi_callbacks_t    *cb;
 	ir_type                     *between_type;
 	set                         *params;
@@ -90,8 +92,6 @@ struct _be_abi_irg_t {
 	ir_node              *init_sp;      /**< The node representing the stack pointer
 	                                         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. */
@@ -180,6 +180,11 @@ void be_abi_call_set_flags(be_abi_call_t *call, be_abi_call_flags_t flags, const
 	call->cb    = cb;
 }
 
+void be_abi_call_set_pop(be_abi_call_t *call, int pop)
+{
+	assert(pop >= 0);
+	call->pop = pop;
+}
 
 /* Set register class for call address */
 void be_abi_call_set_call_address_reg_class(be_abi_call_t *call, const arch_register_class_t *cls)
@@ -188,10 +193,11 @@ void be_abi_call_set_call_address_reg_class(be_abi_call_t *call, const arch_regi
 }
 
 
-void be_abi_call_param_stack(be_abi_call_t *call, int arg_pos, unsigned alignment, unsigned space_before, unsigned space_after)
+void be_abi_call_param_stack(be_abi_call_t *call, int arg_pos, ir_mode *load_mode, unsigned alignment, unsigned space_before, unsigned space_after)
 {
 	be_abi_call_arg_t *arg = get_or_set_call_arg(call, 0, arg_pos, 1);
 	arg->on_stack     = 1;
+	arg->load_mode    = load_mode;
 	arg->alignment    = alignment;
 	arg->space_before = space_before;
 	arg->space_after  = space_after;
@@ -226,6 +232,7 @@ be_abi_call_flags_t be_abi_call_get_flags(const be_abi_call_t *call)
 static be_abi_call_t *be_abi_call_new(const arch_register_class_t *cls_addr)
 {
 	be_abi_call_t *call = xmalloc(sizeof(call[0]));
+	memset(call, 0, sizeof(call[0]));
 
 	call->flags.val  = 0;
 	call->params     = new_set(cmp_call_arg, 16);
@@ -398,14 +405,14 @@ static INLINE int is_on_stack(be_abi_call_t *call, int pos)
  * @param curr_sp The stack pointer node to use.
  * @return The stack pointer after the call.
  */
-static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, ir_node *alloca_copy)
+static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 {
 	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_type *call_tp           = get_Call_type(irn);
 	ir_node *call_ptr          = get_Call_ptr(irn);
-	int n_params               = get_method_n_params(mt);
+	int n_params               = get_method_n_params(call_tp);
 	ir_node *curr_mem          = get_Call_mem(irn);
 	ir_node *bl                = get_nodes_block(irn);
 	pset *results              = pset_new_ptr(8);
@@ -418,9 +425,9 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	ir_mode *mach_mode         = sp->reg_class->mode;
 	struct obstack *obst       = &env->obst;
 	int no_alloc               = call->flags.bits.frame_is_setup_on_call;
+	int n_res                  = get_method_n_ress(call_tp);
 
 	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;
@@ -428,6 +435,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	ir_node *low_call;
 	ir_node **in;
 	ir_node **res_projs;
+	int      n_reg_results = 0;
 	const arch_register_t *reg;
 	const ir_edge_t *edge;
 	int *reg_param_idxs;
@@ -435,7 +443,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	int i, n;
 
 	/* Let the isa fill out the abi description for that call node. */
-	arch_isa_get_call_abi(isa, mt, call);
+	arch_isa_get_call_abi(isa, call_tp, call);
 
 	/* Insert code to put the stack arguments on the stack. */
 	assert(get_Call_n_params(irn) == n_params);
@@ -443,7 +451,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
 		assert(arg);
 		if (arg->on_stack) {
-			int arg_size = get_type_size_bytes(get_method_param_type(mt, i));
+			int arg_size = get_type_size_bytes(get_method_param_type(call_tp, i));
 
 			stack_size += round_up2(arg->space_before, arg->alignment);
 			stack_size += round_up2(arg_size, arg->alignment);
@@ -491,17 +499,11 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		 */
 		if (stack_dir < 0 && !do_seq && !no_alloc) {
 			curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size);
-			if (alloca_copy) {
-				add_irn_dep(curr_sp, alloca_copy);
-				alloca_copy = NULL;
-			}
 		}
 
+		curr_mem = get_Call_mem(irn);
 		if (! do_seq) {
-			obstack_ptr_grow(obst, get_Call_mem(irn));
-			curr_mem = new_NoMem();
-		} else {
-			curr_mem = get_Call_mem(irn);
+			obstack_ptr_grow(obst, curr_mem);
 		}
 
 		for (i = 0; i < n_stack_params; ++i) {
@@ -510,7 +512,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 			ir_node *param         = get_Call_param(irn, p);
 			ir_node *addr          = curr_sp;
 			ir_node *mem           = NULL;
-			ir_type *param_type    = get_method_param_type(mt, p);
+			ir_type *param_type    = get_method_param_type(call_tp, p);
 			int param_size         = get_type_size_bytes(param_type) + arg->space_after;
 
 			/*
@@ -521,10 +523,6 @@ 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) {
-					add_irn_dep(curr_sp, alloca_copy);
-					alloca_copy = NULL;
-				}
 				add_irn_dep(curr_sp, curr_mem);
 			}
 			else {
@@ -545,7 +543,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 			/* Insert a store for primitive arguments. */
 			if (is_atomic_type(param_type)) {
 				ir_node *store;
-				store = new_r_Store(irg, bl, curr_mem, addr, param);
+				ir_node *mem_input = do_seq ? curr_mem : new_NoMem();
+				store = new_r_Store(irg, bl, mem_input, addr, param);
 				mem = new_r_Proj(irg, bl, store, mode_M, pn_Store_M);
 			}
 
@@ -581,7 +580,7 @@ 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) {
-		int j;
+		unsigned 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);
@@ -597,52 +596,35 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 
 	/* search the greatest result proj number */
 
-	/* TODO: what if the result is NOT used? Currently there is
-	 * no way to detect this later, especially there is no way to
-	 * see this in the proj numbers.
-	 * While this is ok for the register allocator, it is bad for
-	 * backends which need to change the be_Call further (x87 simulator
-	 * for instance. However for this particular case the call_type is
-	 * sufficient.).
-	 */
+	res_projs = alloca(n_res * sizeof(res_projs[0]));
+	memset(res_projs, 0, n_res * sizeof(res_projs[0]));
+
 	foreach_out_edge(irn, edge) {
 		const ir_edge_t *res_edge;
-		ir_node *irn = get_edge_src_irn(edge);
+		ir_node         *irn = get_edge_src_irn(edge);
 
-		if (is_Proj(irn) && get_Proj_proj(irn) == pn_Call_T_result) {
-			res_proj = irn;
-			foreach_out_edge(irn, res_edge) {
-				int proj;
-				be_abi_call_arg_t *arg;
-				ir_node *res = get_edge_src_irn(res_edge);
-
-				assert(is_Proj(res));
-
-				proj = get_Proj_proj(res);
-				arg  = get_call_arg(call, 1, proj);
-
-				/*
-					shift the proj number to the right, since we will drop the
-					unspeakable Proj_T from the Call. Therefore, all real argument
-					Proj numbers must be increased by pn_be_Call_first_res
-				*/
-				proj += pn_be_Call_first_res;
-				set_Proj_proj(res, proj);
-				obstack_ptr_grow(obst, res);
-
-				if (proj > curr_res_proj)
-					curr_res_proj = proj;
-				if (arg->in_reg) {
-					pset_remove_ptr(caller_save, arg->reg);
-					//pmap_insert(arg_regs, arg->reg, INT_TO_PTR(proj + 1))
-				}
-			}
+		if(!is_Proj(irn) || get_Proj_proj(irn) != pn_Call_T_result)
+			continue;
+
+		foreach_out_edge(irn, res_edge) {
+			int proj;
+			ir_node *res = get_edge_src_irn(res_edge);
+
+			assert(is_Proj(res));
+
+			proj = get_Proj_proj(res);
+			assert(proj < n_res);
+			assert(res_projs[proj] == NULL);
+			res_projs[proj] = res;
 		}
+		res_proj = irn;
+		break;
 	}
 
-	curr_res_proj++;
-	obstack_ptr_grow(obst, NULL);
-	res_projs = obstack_finish(obst);
+	/** TODO: this is not correct for cases where return values are passed
+	 * on the stack, but no known ABI does this currentl...
+	 */
+	n_reg_results = n_res;
 
 	/* make the back end call node and set its register requirements. */
 	for (i = 0; i < n_reg_params; ++i) {
@@ -665,18 +647,57 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		/* 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));
+		                       n_reg_results + pn_be_Call_first_res + 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_reg_results + pn_be_Call_first_res + pset_count(caller_save),
 		                       n_ins, in, get_Call_type(irn));
 	}
+	be_Call_set_pop(low_call, call->pop);
 	ARR_APP1(ir_node *, env->calls, low_call);
 
+	/* create new stack pointer */
+	curr_sp = new_r_Proj(irg, bl, low_call, get_irn_mode(curr_sp),
+	                     pn_be_Call_sp);
+	be_set_constr_single_reg(low_call, BE_OUT_POS(pn_be_Call_sp), sp);
+	arch_set_irn_register(arch_env, curr_sp, sp);
+	be_node_set_flags(low_call, BE_OUT_POS(pn_be_Call_sp),
+			arch_irn_flags_ignore | arch_irn_flags_modify_sp);
+
+	for(i = 0; i < n_res; ++i) {
+		int pn;
+		ir_node           *proj = res_projs[i];
+		be_abi_call_arg_t *arg  = get_call_arg(call, 1, i);
+
+		/* returns values on stack not supported yet */
+		assert(arg->in_reg);
+
+		/*
+			shift the proj number to the right, since we will drop the
+			unspeakable Proj_T from the Call. Therefore, all real argument
+			Proj numbers must be increased by pn_be_Call_first_res
+		*/
+		pn = i + pn_be_Call_first_res;
+
+		if(proj == NULL) {
+			ir_type *res_type = get_method_res_type(call_tp, i);
+			ir_mode *mode     = get_type_mode(res_type);
+			proj              = new_r_Proj(irg, bl, low_call, mode, pn);
+			res_projs[i]      = proj;
+		} else {
+			set_Proj_pred(proj, low_call);
+			set_Proj_proj(proj, pn);
+		}
+
+		if (arg->in_reg) {
+			pset_remove_ptr(caller_save, arg->reg);
+		}
+	}
+
 	/*
 		Set the register class of the call address to
 		the backend provided class (default: stack pointer class)
@@ -695,62 +716,65 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	}
 
 	/* Set the register constraints of the results. */
-	for (i = 0; res_projs[i]; ++i) {
-		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, 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
+	for (i = 0; i < n_res; ++i) {
+		ir_node                 *proj = res_projs[i];
+		const be_abi_call_arg_t *arg  = get_call_arg(call, 1, i);
+		int                      pn   = get_Proj_proj(proj);
 
 		assert(arg->in_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);
+		arch_set_irn_register(arch_env, proj, arg->reg);
 	}
 	obstack_free(obst, in);
 	exchange(irn, low_call);
 
-	/* redirect the result projs to the lowered call instead of the Proj_T */
-	for (i = 0; res_projs[i]; ++i)
-		set_Proj_pred(res_projs[i], low_call);
-
-	/* set the now unnecessary projT to bad */
+	/* kill the ProjT node */
 	if (res_proj != NULL) {
 		be_kill_node(res_proj);
 	}
 
 	/* Make additional projs for the caller save registers
 	   and the Keep node which keeps them alive. */
-	if (pset_count(caller_save) > 0) {
+	if (1 || pset_count(caller_save) + n_reg_results > 0) {
 		const arch_register_t *reg;
 		ir_node               **in, *keep;
-		int                   i, n;
+		int                   i;
+		int                   n = 0;
+		int                   curr_res_proj
+			= pn_be_Call_first_res + n_reg_results;
+
+		/* also keep the stack pointer */
+		++n;
+		set_irn_link(curr_sp, (void*) sp);
+		obstack_ptr_grow(obst, curr_sp);
 
-		for (reg = pset_first(caller_save), n = 0; reg; reg = pset_next(caller_save), ++n) {
-			ir_node *proj = new_r_Proj(irg, bl, low_call, reg->reg_class->mode, curr_res_proj);
+		for (reg = pset_first(caller_save); reg; reg = pset_next(caller_save), ++n) {
+			ir_node *proj = new_r_Proj(irg, bl, low_call, reg->reg_class->mode,
+			                           curr_res_proj);
 
 			/* memorize the register in the link field. we need afterwards to set the register class of the keep correctly. */
 			be_set_constr_single_reg(low_call, BE_OUT_POS(curr_res_proj), reg);
+			arch_set_irn_register(arch_env, proj, reg);
 
 			/* a call can produce ignore registers, in this case set the flag and register for the Proj */
 			if (arch_register_type_is(reg, ignore)) {
-				arch_set_irn_register(env->birg->main_env->arch_env, proj, reg);
-				be_node_set_flags(low_call, BE_OUT_POS(curr_res_proj), arch_irn_flags_ignore);
+				be_node_set_flags(low_call, BE_OUT_POS(curr_res_proj),
+				                  arch_irn_flags_ignore);
 			}
 
-			set_irn_link(proj, (void *) reg);
+			set_irn_link(proj, (void*) reg);
 			obstack_ptr_grow(obst, proj);
 			curr_res_proj++;
 		}
 
+		for(i = 0; i < n_reg_results; ++i) {
+			ir_node *proj = res_projs[i];
+			const arch_register_t *reg = arch_get_irn_register(arch_env, proj);
+			set_irn_link(proj, (void*) reg);
+			obstack_ptr_grow(obst, proj);
+		}
+		n += n_reg_results;
+
 		/* create the Keep for the caller save registers */
 		in   = (ir_node **) obstack_finish(obst);
 		keep = be_new_Keep(NULL, irg, bl, n, in);
@@ -762,6 +786,9 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 	}
 
 	/* Clean up the stack. */
+	assert(stack_size >= call->pop);
+	stack_size -= call->pop;
+
 	if (stack_size > 0) {
 		ir_node *mem_proj = NULL;
 
@@ -774,18 +801,13 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
 		}
 
 		if (! mem_proj) {
-			mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_Call_M);
+			mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_be_Call_M_regular);
 			keep_alive(mem_proj);
 		}
 
 		 /* Clean up the stack frame if we allocated it */
 		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) {
-				add_irn_dep(curr_sp, alloca_copy);
-				alloca_copy = NULL;
-			}
 		}
 	}
 
@@ -809,10 +831,12 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i
  *
  * @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) {
+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);
+		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);
@@ -827,7 +851,7 @@ static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size, ir_gr
  * Adjust an alloca.
  * The alloca is transformed into a back end alloca node and connected to the stack nodes.
  */
-static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp, ir_node **result_copy)
+static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
 {
 	ir_node *block;
 	ir_graph *irg;
@@ -837,7 +861,7 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 	dbg_info *dbg;
 
 	const ir_edge_t *edge;
-	ir_node *new_alloc, *size, *addr, *copy, *ins[2];
+	ir_node *new_alloc, *size, *addr, *ins[2];
 	unsigned stack_alignment;
 
 	if (get_Alloc_where(alloc) != stack_alloc) {
@@ -879,10 +903,11 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 
 	/* 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);
+		tarval *tv    = new_tarval_from_long(get_type_size_bytes(type),
+		                                     mode_Iu);
 		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);
+		ir_node *mul  = new_rd_Mul(dbg, irg, block, get_Alloc_size(alloc),
+		                           cnst, mode_Iu);
 		size = mul;
 	} else {
 		size = get_Alloc_size(alloc);
@@ -895,8 +920,8 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 	/* 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);
+	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) {
@@ -919,19 +944,9 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
 	/* fix projnum of alloca res */
 	set_Proj_proj(alloc_res, pn_be_AddSP_res);
 
-	addr = env->isa->stack_dir < 0 ? alloc_res : curr_sp;
-
-	/* copy the address away, since it could be used after further stack pointer modifications. */
-	/* Let it point curr_sp just for the moment, I'll reroute it in a second. */
-	*result_copy = copy = be_new_Copy(env->isa->sp->reg_class, irg, block, curr_sp);
-
-	/* Let all users of the Alloc() result now point to the copy. */
-	edges_reroute(alloc_res, copy, irg);
-
-	/* Rewire the copy appropriately. */
-	set_irn_n(copy, be_pos_Copy_op, addr);
-
-	curr_sp = alloc_res;
+	addr    = alloc_res;
+	curr_sp = new_r_Proj(irg, block, new_alloc,  get_irn_mode(curr_sp),
+	                     pn_be_AddSP_sp);
 
 	return curr_sp;
 }  /* adjust_alloc */
@@ -985,7 +1000,7 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
 	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);
+	res = new_r_Proj(irg, block, subsp, sp_mode, pn_be_SubSP_sp);
 
 	/* we need to sync the memory */
 	in[0] = get_Free_mem(free);
@@ -1109,7 +1124,6 @@ static void process_calls_in_block(ir_node *bl, void *data)
 	if(n > 0) {
 		ir_node *keep;
 		ir_node **nodes;
-		ir_node *copy = NULL;
 		int i;
 
 		nodes = obstack_finish(&env->obst);
@@ -1123,10 +1137,10 @@ static void process_calls_in_block(ir_node *bl, void *data)
 			DBG((env->dbg, LEVEL_3, "\tprocessing call %+F\n", irn));
 			switch(get_irn_opcode(irn)) {
 			case iro_Call:
-				curr_sp = adjust_call(env, irn, curr_sp, copy);
+				curr_sp = adjust_call(env, irn, curr_sp);
 				break;
 			case iro_Alloc:
-				curr_sp = adjust_alloc(env, irn, curr_sp, &copy);
+				curr_sp = adjust_alloc(env, irn, curr_sp);
 				break;
 			case iro_Free:
 				curr_sp = adjust_free(env, irn, curr_sp);
@@ -1139,8 +1153,10 @@ 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 */
-		if(curr_sp != env->init_sp) {
+		/* Keep the last stack state in the block by tying it to Keep node,
+		 * the proj from calls is already kept */
+		if(curr_sp != env->init_sp
+				&& !(is_Proj(curr_sp) && be_is_Call(get_Proj_pred(curr_sp)))) {
 			nodes[0] = curr_sp;
 			keep     = be_new_Keep(env->isa->sp->reg_class, get_irn_irg(bl),
 			                       bl, 1, nodes);
@@ -1166,86 +1182,6 @@ static void process_calls(be_abi_irg_t *env)
 	heights_free(ir_heights);
 }
 
-#if 0 /*
-static ir_node *setup_frame(be_abi_irg_t *env)
-{
-	const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
-	const arch_register_t *sp = isa->sp;
-	const arch_register_t *bp = isa->bp;
-	be_abi_call_flags_bits_t flags = env->call->flags.bits;
-	ir_graph *irg      = env->birg->irg;
-	ir_node *bl        = get_irg_start_block(irg);
-	ir_node *no_mem    = get_irg_no_mem(irg);
-	ir_node *old_frame = get_irg_frame(irg);
-	ir_node *stack     = pmap_get(env->regs, (void *) sp);
-	ir_node *frame     = pmap_get(env->regs, (void *) bp);
-
-	int stack_nr       = get_Proj_proj(stack);
-
-	if(flags.try_omit_fp) {
-		stack = be_new_IncSP(sp, irg, bl, stack, no_mem, BE_STACK_FRAME_SIZE_EXPAND);
-		frame = stack;
-	}
-
-	else {
-		frame = be_new_Copy(bp->reg_class, irg, bl, stack);
-
-		be_node_set_flags(frame, -1, arch_irn_flags_dont_spill);
-		if(!flags.fp_free) {
-			be_set_constr_single_reg(frame, -1, bp);
-			be_node_set_flags(frame, -1, arch_irn_flags_ignore);
-			arch_set_irn_register(env->birg->main_env->arch_env, frame, bp);
-		}
-
-		stack = be_new_IncSP(sp, irg, bl, stack, frame, BE_STACK_FRAME_SIZE_EXPAND);
-	}
-
-	be_node_set_flags(env->reg_params, -(stack_nr + 1), arch_irn_flags_ignore);
-	env->init_sp = stack;
-	set_irg_frame(irg, frame);
-	edges_reroute(old_frame, frame, irg);
-
-	return frame;
-}
-
-static void clearup_frame(be_abi_irg_t *env, ir_node *ret, pmap *reg_map, struct obstack *obst)
-{
-	const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
-	const arch_register_t *sp = isa->sp;
-	const arch_register_t *bp = isa->bp;
-	ir_graph *irg      = env->birg->irg;
-	ir_node *ret_mem   = get_Return_mem(ret);
-	ir_node *frame     = get_irg_frame(irg);
-	ir_node *bl        = get_nodes_block(ret);
-	ir_node *stack     = get_irn_link(bl);
-
-	pmap_entry *ent;
-
-	if(env->call->flags.bits.try_omit_fp) {
-		stack = be_new_IncSP(sp, irg, bl, stack, ret_mem, -BE_STACK_FRAME_SIZE_SHRINK);
-	}
-
-	else {
-		stack = be_new_SetSP(sp, irg, bl, stack, frame, ret_mem);
-		be_set_constr_single_reg(stack, -1, sp);
-		be_node_set_flags(stack, -1, arch_irn_flags_ignore);
-	}
-
-	pmap_foreach(env->regs, ent) {
-		const arch_register_t *reg = ent->key;
-		ir_node *irn               = ent->value;
-
-		if(reg == sp)
-			obstack_ptr_grow(&env->obst, stack);
-		else if(reg == bp)
-			obstack_ptr_grow(&env->obst, frame);
-		else if(arch_register_type_is(reg, callee_save) || arch_register_type_is(reg, ignore))
-			obstack_ptr_grow(obst, irn);
-	}
-}
-*/
-#endif
-
 /**
  * Computes the stack argument layout type.
  * Changes a possibly allocated value param type by moving
@@ -1374,7 +1310,7 @@ static reg_node_map_t *reg_map_to_arr(struct obstack *obst, pmap *reg_map)
 	int i = 0;
 	reg_node_map_t *res = obstack_alloc(obst, n * sizeof(res[0]));
 
-	pmap_foreach(reg_map, ent) {
+	foreach_pmap(reg_map, ent) {
 		res[i].reg = ent->key;
 		res[i].irn = ent->value;
 		i++;
@@ -1453,15 +1389,18 @@ static ir_node *create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pm
  * @param mem     the current memory
  * @param n_res   number of return results
  */
-static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, ir_node *mem, int n_res) {
-	be_abi_call_t *call = env->call;
+static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
+		ir_node *mem, int n_res)
+{
+	be_abi_call_t *call        = env->call;
 	const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
-
+	dbg_info *dbgi;
 	pmap *reg_map  = pmap_create();
 	ir_node *keep  = pmap_get(env->keep_map, bl);
 	int in_max;
 	ir_node *ret;
 	int i, n;
+	unsigned pop;
 	ir_node **in;
 	ir_node *stack;
 	const arch_register_t **regs;
@@ -1490,7 +1429,7 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i
 	}
 
 	/* Add uses of the callee save registers. */
-	pmap_foreach(env->regs, ent) {
+	foreach_pmap(env->regs, ent) {
 		const arch_register_t *reg = ent->key;
 		if(arch_register_type_is(reg, callee_save) || arch_register_type_is(reg, ignore))
 			pmap_insert(reg_map, ent->key, ent->value);
@@ -1530,7 +1469,7 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i
 	}
 
 	/* grow the rest of the stuff. */
-	pmap_foreach(reg_map, ent) {
+	foreach_pmap(reg_map, ent) {
 		if(ent->value) {
 			in[n]     = ent->value;
 			regs[n++] = ent->key;
@@ -1538,7 +1477,14 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i
 	}
 
 	/* The in array for the new back end return is now ready. */
-	ret = be_new_Return(irn ? get_irn_dbg_info(irn) : NULL, env->birg->irg, bl, n_res, n, in);
+	if(irn != NULL) {
+		dbgi = get_irn_dbg_info(irn);
+	} else {
+		dbgi = NULL;
+	}
+	/* we have to pop the shadow parameter in in case of struct returns */
+	pop = call->pop;
+	ret = be_new_Return(dbgi, env->birg->irg, bl, n_res, pop, n, in);
 
 	/* Set the register classes of the return's parameter accordingly. */
 	for(i = 0; i < n; ++i)
@@ -1630,7 +1576,7 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_entity *value_
 		ir_node *frame, *imem, *nmem, *store, *mem, *args, *args_bl;
 		const ir_edge_t *edge;
 		optimization_state_t state;
-		int offset;
+		unsigned offset;
 
 		foreach_block_succ(start_bl, edge) {
 			ir_node *succ = get_edge_src_irn(edge);
@@ -1684,11 +1630,11 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_entity *value_
 		frame_tp = get_irg_frame_type(irg);
 		offset   = get_type_size_bytes(frame_tp);
 		for (ent = new_list; ent; ent = get_entity_link(ent)) {
-			ir_type *tp = get_entity_type(ent);
-			int align = get_type_alignment_bytes(tp);
+			ir_type  *tp   = get_entity_type(ent);
+			unsigned align = get_type_alignment_bytes(tp);
 
 			offset += align - 1;
-			offset &= -align;
+			offset &= ~(align - 1);
 			set_entity_owner(ent, frame_tp);
 			add_class_member(frame_tp, ent);
 			/* must be automatic to set a fixed layout */
@@ -1700,6 +1646,7 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_entity *value_
 	}
 }
 
+#if 1
 /**
  * The start block has no jump, instead it has an initial exec Proj.
  * The backend wants to handle all blocks the same way, so we replace
@@ -1730,6 +1677,7 @@ static void fix_start_block(ir_node *block, void *env) {
 		}
 	}
 }
+#endif
 
 /**
  * Modify the irg itself and the frame type.
@@ -1749,12 +1697,12 @@ static void modify_irg(be_abi_irg_t *env)
 	pset *dont_save           = pset_new_ptr(8);
 
 	int n_params;
-	int i, j, n, temp;
+	int i, n;
+	unsigned j;
 
 	reg_node_map_t *rm;
 	const arch_register_t *fp_reg;
 	ir_node *frame_pointer;
-	ir_node *barrier;
 	ir_node *reg_params_bl;
 	ir_node **args;
 	ir_node *arg_tuple;
@@ -1812,9 +1760,11 @@ static void modify_irg(be_abi_irg_t *env)
 	arg_tuple = get_irg_args(irg);
 	foreach_out_edge(arg_tuple, edge) {
 		ir_node *irn = get_edge_src_irn(edge);
-		int nr       = get_Proj_proj(irn);
-		args[nr]     = irn;
-		DBG((dbg, LEVEL_2, "\treading arg: %d -> %+F\n", nr, irn));
+		if (! is_Anchor(irn)) {
+			int nr       = get_Proj_proj(irn);
+			args[nr]     = irn;
+			DBG((dbg, LEVEL_2, "\treading arg: %d -> %+F\n", nr, irn));
+		}
 	}
 
 	arg_type = compute_arg_type(env, call, method_type, &param_map);
@@ -1910,7 +1860,7 @@ static void modify_irg(be_abi_irg_t *env)
 	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);
+	create_barrier(env, bl, &mem, env->regs, 0);
 
 	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);
@@ -1942,21 +1892,26 @@ static void modify_irg(be_abi_irg_t *env)
 
 			if (arg->in_reg) {
 				repl = pmap_get(env->regs, (void *) arg->reg);
-			}
+			} else if(arg->on_stack) {
+				ir_node *addr = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
 
-			else if(arg->on_stack) {
-				/* For atomic parameters which are actually used, we create a StackParam node. */
+				/* For atomic parameters which are actually used, we create a Load node. */
 				if(is_atomic_type(param_type) && get_irn_n_edges(args[i]) > 0) {
-					ir_mode *mode                    = get_type_mode(param_type);
-					const arch_register_class_t *cls = arch_isa_get_reg_class_for_mode(isa, mode);
-					repl = be_new_StackParam(cls, isa->bp->reg_class, irg, reg_params_bl, mode, frame_pointer, arg->stack_ent);
-				}
+					ir_mode *mode      = get_type_mode(param_type);
+					ir_mode *load_mode = arg->load_mode;
 
-				/* 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. */
-				else {
-					repl = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
+					ir_node *load = new_r_Load(irg, reg_params_bl, new_NoMem(), addr, load_mode);
+					set_irn_pinned(load, op_pin_state_floats);
+					repl = new_r_Proj(irg, reg_params_bl, load, load_mode, pn_Load_res);
+
+					if (mode != load_mode) {
+						repl = new_r_Conv(irg, reg_params_bl, repl, mode);
+					}
+				} else {
+					/* 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. */
+					repl = addr;
 				}
 			}
 
@@ -1972,8 +1927,8 @@ static void modify_irg(be_abi_irg_t *env)
 		}
 	}
 
-	/* the arg proj is not needed anymore now */
-	assert(get_irn_n_edges(arg_tuple) == 0);
+	/* the arg proj is not needed anymore now and should be only used by the anchor */
+	assert(get_irn_n_edges(arg_tuple) == 1);
 	be_kill_node(arg_tuple);
 	set_irg_args(irg, new_rd_Bad(irg));
 
@@ -1982,7 +1937,9 @@ static void modify_irg(be_abi_irg_t *env)
 		ir_node *irn = get_Block_cfgpred(end, i);
 
 		if (is_Return(irn)) {
-			ir_node *ret = create_be_return(env, irn, get_nodes_block(irn), get_Return_mem(irn), get_Return_n_ress(irn));
+			ir_node *blk = get_nodes_block(irn);
+			ir_node *mem = get_Return_mem(irn);
+			ir_node *ret = create_be_return(env, irn, blk, mem, get_Return_n_ress(irn));
 			exchange(irn, ret);
 		}
 	}
@@ -1993,8 +1950,8 @@ static void modify_irg(be_abi_irg_t *env)
 	obstack_free(&env->obst, args);
 
 	/* handle start block here (place a jump in the block) */
-	temp = 0;
-	irg_block_walk_graph(irg, fix_start_block, NULL, &temp);
+	i = 0;
+	irg_block_walk_graph(irg, fix_start_block, NULL, &i);
 }
 
 /** Fix the state inputs of calls that still hang on unknowns */
@@ -2008,7 +1965,7 @@ void fix_call_state_inputs(be_abi_irg_t *env)
 	/* Collect caller save registers */
 	n = arch_isa_get_n_reg_class(isa);
 	for(i = 0; i < n; ++i) {
-		int j;
+		unsigned 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);
@@ -2108,7 +2065,7 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 
 	/* 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) {
+	foreach_pmap(env->regs, ent) {
 		survive_dce_register_irn(env->dce_survivor, (ir_node **) &ent->value);
 	}
 
@@ -2256,10 +2213,10 @@ static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
 
 			if(be_is_IncSP(irn)) {
 				if(ofs == BE_STACK_FRAME_SIZE_EXPAND) {
-					ofs = get_type_size_bytes(get_irg_frame_type(env->birg->irg));
+					ofs = (int)get_type_size_bytes(get_irg_frame_type(env->birg->irg));
 					be_set_IncSP_offset(irn, ofs);
 				} else if(ofs == BE_STACK_FRAME_SIZE_SHRINK) {
-					ofs = - get_type_size_bytes(get_irg_frame_type(env->birg->irg));
+					ofs = - (int)get_type_size_bytes(get_irg_frame_type(env->birg->irg));
 					be_set_IncSP_offset(irn, ofs);
 				}
 			}
@@ -2323,11 +2280,6 @@ ir_node *be_abi_get_ignore_irn(be_abi_irg_t *abi, const arch_register_t *reg)
 	return pmap_get(abi->regs, (void *) reg);
 }
 
-ir_node *be_abi_get_start_barrier(be_abi_irg_t *abi)
-{
-	return abi->start_barrier;
-}
-
 /**
  * Returns non-zero if the ABI has omitted the frame pointer in
  * the current graph.