X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Fbe%2Fbeabi.c;h=5f88bd2dce0737e8bd3c15799b04c042ebeda1eb;hb=335c4762b4ac75793f3614d01c197a5289b4a946;hp=fb14150092faa673580c7b98c8c28b6e88a402f9;hpb=651518e2c720d7fdde9500449028f400d50f7d8f;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index fb1415009..5f88bd2dc 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -11,7 +11,7 @@
 #include "obst.h"
 
 #include "type.h"
-#include "survive_dce.h"
+#include "irgopt.h"
 
 #include "irgraph_t.h"
 #include "irnode_t.h"
@@ -20,19 +20,22 @@
 #include "irgmod.h"
 #include "irgwalk.h"
 #include "irprintf_t.h"
+#include "irgopt.h"
 
 #include "be.h"
 #include "beabi.h"
 #include "bearch.h"
 #include "benode_t.h"
+#include "belive_t.h"
 #include "besched_t.h"
 
 #define MAX(x, y) ((x) > (y) ? (x) : (y))
 #define MIN(x, y) ((x) < (y) ? (x) : (y))
 
 typedef struct _be_abi_call_arg_t {
-	unsigned is_res : 1;
-	unsigned in_reg : 1;
+	unsigned is_res   : 1;
+	unsigned in_reg   : 1;
+	unsigned on_stack : 1;
 
 	int pos;
 	const arch_register_t *reg;
@@ -41,6 +44,7 @@ typedef struct _be_abi_call_arg_t {
 
 struct _be_abi_call_t {
 	be_abi_call_flags_t flags;
+	const be_abi_callbacks_t *cb;
 	type *between_type;
 	set *params;
 };
@@ -86,6 +90,8 @@ struct _be_abi_irg_t {
 
 	int                  start_block_bias;	/**< The stack bias at the end of the start block. */
 
+	void                 *cb;           /**< ABI Callback self pointer. */
+
 	arch_irn_handler_t irn_handler;
 	arch_irn_ops_t     irn_ops;
 };
@@ -121,6 +127,7 @@ static be_abi_call_arg_t *get_or_set_call_arg(be_abi_call_t *call, int is_res, i
 	be_abi_call_arg_t arg;
 	unsigned hash;
 
+	memset(&arg, 0, sizeof(arg));
 	arg.is_res = is_res;
 	arg.pos    = pos;
 
@@ -136,15 +143,16 @@ static INLINE be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, i
 	return get_or_set_call_arg(call, is_res, pos, 0);
 }
 
-void be_abi_call_set_flags(be_abi_call_t *call, be_abi_call_flags_t flags, ir_type *between_type)
+void be_abi_call_set_flags(be_abi_call_t *call, be_abi_call_flags_t flags, const be_abi_callbacks_t *cb)
 {
-	call->flags            = flags;
-	call->between_type     = between_type;
+	call->flags        = flags;
+	call->cb           = cb;
 }
 
 void be_abi_call_param_stack(be_abi_call_t *call, int arg_pos)
 {
 	be_abi_call_arg_t *arg = get_or_set_call_arg(call, 0, arg_pos, 1);
+	arg->on_stack = 1;
 }
 
 void be_abi_call_param_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
@@ -161,11 +169,17 @@ void be_abi_call_res_reg(be_abi_call_t *call, int arg_pos, const arch_register_t
 	arg->reg = reg;
 }
 
+be_abi_call_flags_t be_abi_call_get_flags(const be_abi_call_t *call)
+{
+	return call->flags;
+}
+
 be_abi_call_t *be_abi_call_new(void)
 {
 	be_abi_call_t *call = malloc(sizeof(call[0]));
-	call->flags.val = 0;
-	call->params    = new_set(cmp_call_arg, 16);
+	call->flags.val  = 0;
+	call->params     = new_set(cmp_call_arg, 16);
+	call->cb         = NULL;
 	return call;
 }
 
@@ -299,39 +313,16 @@ static INLINE entity *get_sel_ent(ir_node *irn)
  */
 static void lower_frame_sels_walker(ir_node *irn, void *data)
 {
-	const arch_register_class_t *cls;
-	be_abi_irg_t *env = data;
-	const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
-	ir_graph *irg = get_irn_irg(irn);
-	ir_node *frame = get_irg_frame(irg);
 	ir_node *nw  = NULL;
-	opcode opc   = get_irn_opcode(irn);
-
-	if(opc == iro_Load) {
-		ir_node *bl  = get_nodes_block(irn);
-		ir_node *sel = get_Load_ptr(irn);
-		entity *ent  = get_sel_ent(sel);
-		cls = arch_isa_get_reg_class_for_mode(isa, get_Load_mode(irn));
-		if(ent != NULL)
-			nw = be_new_FrameLoad(isa->sp->reg_class, cls, irg, bl, get_Load_mem(irn), frame, ent);
-	}
+	entity *ent = get_sel_ent(irn);
 
-	else if(opc == iro_Store) {
-		ir_node *bl  = get_nodes_block(irn);
-		ir_node *val = get_Store_value(irn);
-		ir_node *sel = get_Store_ptr(irn);
-		entity *ent  = get_sel_ent(sel);
-		cls = arch_isa_get_reg_class_for_mode(isa, get_irn_mode(val));
-		if(ent != NULL)
-			nw = be_new_FrameStore(isa->sp->reg_class, cls,	irg, bl, get_Store_mem(irn), frame, val, ent);
-	}
+	if(ent != NULL) {
+		be_abi_irg_t *env = data;
+		ir_node *bl       = get_nodes_block(irn);
+		ir_graph *irg     = get_irn_irg(bl);
+		ir_node *frame    = get_irg_frame(irg);
 
-	else {
-		entity *ent = get_sel_ent(irn);
-		if(ent != NULL) {
-			ir_node *bl  = get_nodes_block(irn);
-			nw = be_new_FrameAddr(isa->sp->reg_class, irg, bl, frame, ent);
-		}
+		nw = be_new_FrameAddr(env->isa->sp->reg_class, irg, bl, frame, ent);
 	}
 
 	if(nw != NULL)
@@ -402,7 +393,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	for(i = 0; i < n_params; ++i) {
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
 		assert(arg);
-		if(!arg->in_reg) {
+		if(arg->on_stack) {
 			stack_size += get_type_size_bytes(get_method_param_type(mt, i));
 			obstack_int_grow(obst, i);
 			n_pos++;
@@ -535,8 +526,10 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
 				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))
+				}
 			}
 		}
 	}
@@ -560,9 +553,18 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	/* Set the register classes and constraints of the Call parameters. */
 	for(i = 0; i < n_low_args; ++i) {
 		int index = low_args[i];
-		const arch_register_t *reg = get_call_arg(call, 0, index);
-		assert(reg != NULL);
-		be_set_constr_single_reg(low_call, index, reg);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, index);
+		assert(arg->reg != NULL);
+
+#if 0
+		if(pmap_contains(arg_regs, (void *) arg->reg)) {
+			int out_proj_num = PTR_TO_INT(be_abi_reg_map_get(arg_regs, arg->reg)) - 1;
+			be_node_set_must_be_same(low_call, out_proj_num, low_args[i]);
+		}
+
+		else
+#endif
+			be_set_constr_single_reg(low_call, index, arg->reg);
 	}
 
 	/* Set the register constraints of the results. */
@@ -641,14 +643,41 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
 {
 	if(get_Alloc_where(alloc) == stack_alloc) {
+		ir_node *bl        = get_nodes_block(alloc);
+		ir_graph *irg      = get_irn_irg(bl);
+		ir_node *alloc_mem = NULL;
+		ir_node *alloc_res = NULL;
+
+		const ir_edge_t *edge;
 		ir_node *new_alloc;
 
-		ir_node *bl   = get_nodes_block(alloc);
-		ir_graph *irg = get_irn_irg(bl);
+		env->call->flags.bits.try_omit_fp = 0;
+
+		new_alloc = be_new_AddSP(env->isa->sp, irg, bl, curr_sp, get_Alloc_size(alloc));
 
-		new_alloc = be_new_Alloca(env->isa->sp, irg, bl, get_Alloc_mem(alloc), curr_sp, get_Alloc_size(alloc));
-		exchange(alloc, new_alloc);
-		curr_sp = new_r_Proj(irg, bl, new_alloc, mode_P, pn_Alloc_res);
+		foreach_out_edge(alloc, edge) {
+			ir_node *irn = get_edge_src_irn(edge);
+
+			assert(is_Proj(irn));
+			switch(get_Proj_proj(irn)) {
+			case pn_Alloc_M:
+				alloc_mem = irn;
+				break;
+			case pn_Alloc_res:
+				alloc_res = irn;
+				break;
+			default:
+				break;
+			}
+		}
+
+		assert(alloc_res != NULL);
+		exchange(alloc_res, env->isa->stack_dir < 0 ? new_alloc : curr_sp);
+
+		if(alloc_mem != NULL)
+			exchange(alloc_mem, new_r_NoMem(irg));
+
+		curr_sp = new_alloc;
 	}
 
 	return curr_sp;
@@ -717,8 +746,11 @@ static int cmp_call_dependecy(const void *c1, const void *c2)
 static void link_calls_in_block_walker(ir_node *irn, void *data)
 {
 	if(is_Call(irn)) {
-		ir_node *bl = get_nodes_block(irn);
-		void *save  = get_irn_link(bl);
+		be_abi_irg_t *env = data;
+		ir_node *bl       = get_nodes_block(irn);
+		void *save        = get_irn_link(bl);
+
+		env->call->flags.bits.irg_is_leaf = 0;
 
 		set_irn_link(irn, save);
 		set_irn_link(bl, irn);
@@ -783,37 +815,11 @@ static void process_calls(be_abi_irg_t *env)
 {
 	ir_graph *irg = env->birg->irg;
 
-	irg_walk_graph(irg, firm_clear_link, link_calls_in_block_walker, NULL);
+	env->call->flags.bits.irg_is_leaf = 1;
+	irg_walk_graph(irg, firm_clear_link, link_calls_in_block_walker, env);
 	irg_block_walk_graph(irg, NULL, process_calls_in_block, env);
 }
 
-#if 0
-/**
- * Walker to implement alloca-style allocations.
- * They are implemented using an add to the stack pointer
- * and a copy instruction.
- */
-static void implement_stack_alloc(be_abi_irg_t *env, ir_node *irn)
-{
-	const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
-	ir_node *bl           = get_nodes_block(irn);
-	ir_node *res          = env->init_sp;
-	ir_node *size;
-
-	assert(get_irn_opcode(irn) == iro_Alloc && get_Alloc_where(irn) == stack_alloc);
-
-	size = get_Alloc_size(irn);
-	if(isa->stack_dir > 0)
-		res = be_new_Copy(isa->sp->reg_class, env->birg->irg, bl, res);
-
-	res = be_new_AddSP(isa->sp, env->birg->irg, bl, res, size);
-
-	if(isa->stack_dir < 0)
-		res = be_new_Copy(isa->sp->reg_class, env->birg->irg, bl, res);
-
-}
-#endif
-
 static void collect_return_walker(ir_node *irn, void *data)
 {
 	if(get_irn_opcode(irn) == iro_Return) {
@@ -863,7 +869,7 @@ static ir_node *setup_frame(be_abi_irg_t *env)
 	return frame;
 }
 
-static void clearup_frame(be_abi_irg_t *env, ir_node *ret, struct obstack *obst)
+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;
@@ -891,11 +897,11 @@ static void clearup_frame(be_abi_irg_t *env, ir_node *ret, struct obstack *obst)
 		ir_node *irn               = ent->value;
 
 		if(reg == sp)
-			irn = stack;
+			obstack_ptr_grow(&env->obst, stack);
 		else if(reg == bp)
-			irn = frame;
-
-		obstack_ptr_grow(obst, irn);
+			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);
 	}
 }
 
@@ -918,7 +924,7 @@ static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type
 		type *param_type       = get_method_param_type(method_type, curr);
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, curr);
 
-		if(!arg->in_reg) {
+		if(arg->on_stack) {
 			snprintf(buf, sizeof(buf), "param_%d", i);
 			arg->stack_ent = new_entity(res, new_id_from_str(buf), param_type);
 			set_entity_offset_bytes(arg->stack_ent, ofs);
@@ -930,13 +936,136 @@ static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type
 	return res;
 }
 
+static void create_register_perms(const arch_isa_t *isa, ir_graph *irg, ir_node *bl, pmap *regs)
+{
+	int i, j, n;
+	struct obstack obst;
+
+	obstack_init(&obst);
+
+	/* Create a Perm after the RegParams node to delimit it. */
+	for(i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
+		const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
+		ir_node *perm;
+		ir_node **in;
+		int n_regs;
+
+		for(n_regs = 0, j = 0; j < cls->n_regs; ++j) {
+			const arch_register_t *reg = &cls->regs[j];
+			ir_node *irn = pmap_get(regs, (void *) reg);
+
+			if(irn && !arch_register_type_is(reg, ignore)) {
+				n_regs++;
+				obstack_ptr_grow(&obst, irn);
+				set_irn_link(irn, (void *) reg);
+			}
+		}
+
+		obstack_ptr_grow(&obst, NULL);
+		in = obstack_finish(&obst);
+		if(n_regs > 0) {
+			perm = be_new_Perm(cls, irg, bl, n_regs, in);
+			for(j = 0; j < n_regs; ++j) {
+				ir_node *arg = in[j];
+				arch_register_t *reg = get_irn_link(arg);
+				pmap_insert(regs, reg, arg);
+				be_set_constr_single_reg(perm, BE_OUT_POS(j), reg);
+			}
+		}
+		obstack_free(&obst, in);
+	}
+
+	obstack_free(&obst, NULL);
+}
+
+typedef struct {
+	const arch_register_t *reg;
+	ir_node *irn;
+} reg_node_map_t;
+
+static int cmp_regs(const void *a, const void *b)
+{
+	const reg_node_map_t *p = a;
+	const reg_node_map_t *q = b;
+
+	if(p->reg->reg_class == q->reg->reg_class)
+		return p->reg->index - q->reg->index;
+	else
+		return p->reg->reg_class - q->reg->reg_class;
+}
+
+static reg_node_map_t *reg_map_to_arr(struct obstack *obst, pmap *reg_map)
+{
+	pmap_entry *ent;
+	int n = pmap_count(reg_map);
+	int i = 0;
+	reg_node_map_t *res = obstack_alloc(obst, n * sizeof(res[0]));
+
+	pmap_foreach(reg_map, ent) {
+		res[i].reg = ent->key;
+		res[i].irn = ent->value;
+		i++;
+	}
+
+	qsort(res, n, sizeof(res[0]), cmp_regs);
+	return res;
+}
+
+static void create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *regs, int in_req)
+{
+	ir_graph *irg = env->birg->irg;
+	int i, n;
+	int n_regs = pmap_count(regs);
+	ir_node *irn;
+	ir_node **in;
+	reg_node_map_t *rm;
+
+	rm = reg_map_to_arr(&env->obst, regs);
+
+	for(i = 0, n = 0; i < n_regs; ++i, ++n)
+		obstack_ptr_grow(&env->obst, rm[i].irn);
+
+	if(mem) {
+		obstack_ptr_grow(&env->obst, *mem);
+		n++;
+	}
+
+	in = (ir_node **) obstack_finish(&env->obst);
+	irn = be_new_Barrier(env->birg->irg, bl, n, in);
+	obstack_free(&env->obst, in);
+
+	for(n = 0; n < n_regs; ++n) {
+		int pos = BE_OUT_POS(n);
+		ir_node *proj;
+		const arch_register_t *reg = rm[n].reg;
+
+		proj = new_r_Proj(env->birg->irg, bl, irn, get_irn_mode(rm[i].irn), n);
+		be_node_set_reg_class(irn, n, reg->reg_class);
+		if(in_req)
+			be_set_constr_single_reg(irn, n, reg);
+		be_set_constr_single_reg(irn, pos, reg);
+		be_node_set_reg_class(irn, pos, reg->reg_class);
+		arch_set_irn_register(env->birg->main_env->arch_env, proj, reg);
+		if(arch_register_type_is(reg, ignore))
+			be_node_set_flags(irn, pos, arch_irn_flags_ignore);
+
+		pmap_insert(regs, (void *) reg, proj);
+	}
+
+	if(mem) {
+		*mem = new_r_Proj(env->birg->irg, bl, irn, mode_M, n);
+	}
+
+	obstack_free(&env->obst, rm);
+}
+
 /**
  * Modify the irg itself and the frame type.
  */
 static void modify_irg(be_abi_irg_t *env)
 {
 	firm_dbg_module_t *dbg    = env->dbg;
-	be_abi_call_t *call       = be_abi_call_new();
+	be_abi_call_t *call       = env->call;
 	const arch_isa_t *isa     = env->birg->main_env->arch_env->isa;
 	const arch_register_t *sp = arch_isa_sp(isa);
 	ir_graph *irg             = env->birg->irg;
@@ -944,21 +1073,26 @@ static void modify_irg(be_abi_irg_t *env)
 	ir_node *end              = get_irg_end_block(irg);
 	ir_node *arg_tuple        = get_irg_args(irg);
 	ir_node *no_mem           = get_irg_no_mem(irg);
+	ir_node *mem              = get_irg_initial_mem(irg);
 	type *method_type         = get_entity_type(get_irg_entity(irg));
+	pset *dont_save           = pset_new_ptr(8);
+	pmap *reg_proj_map        = pmap_create();
 	int n_params              = get_method_n_params(method_type);
 	int max_arg               = 0;
-	int reg_params_nr         = 0;
 	int arg_offset            = 0;
 
 	int i, j, n;
 
+	reg_node_map_t *rm;
+	const arch_register_t *fp_reg;
 	ir_node *frame_pointer;
 	ir_node *reg_params_bl;
-	ir_node **args, **args_repl;
+	ir_node **args;
 	const ir_edge_t *edge;
-	ir_type *arg_type;
+	ir_type *arg_type, *bet_type;
 
 	pmap_entry *ent;
+	bitset_t *used_proj_nr;
 
 	DBG((dbg, LEVEL_1, "introducing abi on %+F\n", irg));
 
@@ -974,11 +1108,10 @@ static void modify_irg(be_abi_irg_t *env)
 		int nr       = get_Proj_proj(irn);
 		max_arg      = MAX(max_arg, nr);
 	}
-	max_arg += 1;
-	args      = obstack_alloc(&env->obst, max_arg * sizeof(args[0]));
-	args_repl = obstack_alloc(&env->obst, max_arg * sizeof(args[0]));
+	max_arg = MAX(max_arg + 1, n_params);
+	args        = obstack_alloc(&env->obst, max_arg * sizeof(args[0]));
 	memset(args, 0, max_arg * sizeof(args[0]));
-	memset(args_repl, 0, max_arg * sizeof(args[0]));
+	used_proj_nr = bitset_alloca(1024);
 
 	/* Fill the argument vector */
 	foreach_out_edge(arg_tuple, edge) {
@@ -988,18 +1121,20 @@ static void modify_irg(be_abi_irg_t *env)
 		DBG((dbg, LEVEL_2, "\treading arg: %d -> %+F\n", nr, irn));
 	}
 
-	/* Get the ABI constraints from the ISA */
-	arch_isa_get_call_abi(isa, method_type, call);
-
-	arg_type     = compute_arg_type(env, call, method_type);
-	stack_frame_init(env->frame, arg_type, call->between_type, get_irg_frame_type(irg), isa->stack_dir);
+	arg_type = compute_arg_type(env, call, method_type);
+	bet_type = call->cb->get_between_type(env->cb);
+	stack_frame_init(env->frame, arg_type, bet_type, get_irg_frame_type(irg), isa->stack_dir);
 
 	/* Count the register params and add them to the number of Projs for the RegParams node */
 	for(i = 0; i < n_params; ++i) {
 		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
-		if(arg->in_reg) {
+		if(arg->in_reg && args[i]) {
 			assert(arg->reg != sp && "cannot use stack pointer as parameter register");
-			pmap_insert(env->regs, (void *) arg->reg, NULL);
+			assert(i == get_Proj_proj(args[i]));
+
+			/* For now, associate the register with the old Proj from Start representing that argument. */
+			pmap_insert(env->regs, (void *) arg->reg, args[i]);
+			bitset_set(used_proj_nr, i);
 			DBG((dbg, LEVEL_2, "\targ #%d -> reg %s\n", i, arg->reg->name));
 		}
 	}
@@ -1009,27 +1144,39 @@ 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, ignore))
 				pmap_insert(env->regs, (void *) reg, NULL);
 		}
 	}
 
 	pmap_insert(env->regs, (void *) sp, NULL);
 	pmap_insert(env->regs, (void *) isa->bp, NULL);
-	reg_params_nr   = 0;
 	reg_params_bl   = get_irg_start_block(irg);
 	env->reg_params = be_new_RegParams(irg, reg_params_bl, pmap_count(env->regs));
 
 	/*
 	 * make proj nodes for the callee save registers.
 	 * memorize them, since Return nodes get those as inputs.
+	 *
+	 * Note, that if a register corresponds to an argument, the regs map contains
+	 * the old Proj from start for that argument.
 	 */
-	for(ent = pmap_first(env->regs); ent; ent = pmap_next(env->regs)) {
-		arch_register_t *reg = ent->key;
-		int pos = -(reg_params_nr + 1);
-		ent->value = new_r_Proj(irg, reg_params_bl, env->reg_params, reg->reg_class->mode, reg_params_nr);
+
+	rm = reg_map_to_arr(&env->obst, env->regs);
+	for(i = 0, n = pmap_count(env->regs); i < n; ++i) {
+		arch_register_t *reg = (void *) rm[i].reg;
+		ir_node *arg_proj    = rm[i].irn;
+		ir_node *proj;
+		ir_mode *mode        = arg_proj ? get_irn_mode(arg_proj) : reg->reg_class->mode;
+		long nr              = i;
+		int pos              = BE_OUT_POS((int) nr);
+
+		assert(nr >= 0);
+		bitset_set(used_proj_nr, nr);
+		proj = new_r_Proj(irg, reg_params_bl, env->reg_params, mode, nr);
+		pmap_insert(env->regs, (void *) reg, proj);
 		be_set_constr_single_reg(env->reg_params, pos, reg);
-		arch_set_irn_register(env->birg->main_env->arch_env, ent->value, reg);
+		arch_set_irn_register(env->birg->main_env->arch_env, proj, reg);
 
 		/*
 		 * If the register is an ignore register,
@@ -1038,17 +1185,26 @@ static void modify_irg(be_abi_irg_t *env)
 		if(arch_register_type_is(reg, ignore))
 			be_node_set_flags(env->reg_params, pos, arch_irn_flags_ignore);
 
-		reg_params_nr++;
-
-		DBG((dbg, LEVEL_2, "\tregister save proj #%d -> reg %s\n", reg_params_nr - 1, reg->name));
+		DBG((dbg, LEVEL_2, "\tregister save proj #%d -> reg %s\n", nr, reg->name));
 	}
+	obstack_free(&env->obst, rm);
+
+	/* Generate the Prologue */
+	fp_reg = call->cb->prologue(env->cb, &mem, env->regs);
+	create_barrier(env, bl, &mem, env->regs, 0);
 
-	/* Insert the code to set up the stack frame */
-	frame_pointer = setup_frame(env);
+	env->init_sp  = be_abi_reg_map_get(env->regs, sp);
+	env->init_sp  = be_new_IncSP(sp, irg, bl, env->init_sp, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+	arch_set_irn_register(env->birg->main_env->arch_env, env->init_sp, sp);
+	be_abi_reg_map_set(env->regs, sp, env->init_sp);
+	frame_pointer = be_abi_reg_map_get(env->regs, sp);
+	set_irg_frame(irg, frame_pointer);
 
 	/* Now, introduce stack param nodes for all parameters passed on the stack */
 	for(i = 0; i < max_arg; ++i) {
 		ir_node *arg_proj = args[i];
+		ir_node *repl     = NULL;
+
 		if(arg_proj != NULL) {
 			be_abi_call_arg_t *arg;
 			ir_type *param_type;
@@ -1059,37 +1215,27 @@ static void modify_irg(be_abi_irg_t *env)
 			param_type = get_method_param_type(method_type, nr);
 
 			if(arg->in_reg) {
-				args_repl[i] = new_r_Proj(irg, reg_params_bl, env->reg_params, get_irn_mode(arg_proj), reg_params_nr);
-				be_set_constr_single_reg(env->reg_params, -(reg_params_nr + 1), arg->reg);
-				reg_params_nr++;
+				repl = pmap_get(env->regs, (void *) arg->reg);
 			}
 
-			/* when the (stack) parameter is primitive, we insert a StackParam
-			node representing the load of that parameter */
-			else {
-
+			else if(arg->on_stack) {
 				/* For atomic parameters which are actually used, we create a StackParam 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);
-					args_repl[i] = be_new_StackParam(cls, isa->bp->reg_class, irg, reg_params_bl, mode, frame_pointer, arg->stack_ent);
+					repl = be_new_StackParam(cls, isa->bp->reg_class, irg, reg_params_bl, mode, frame_pointer, arg->stack_ent);
 				}
 
 				/* 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 {
-					args_repl[i] = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
+					repl = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
 				}
 			}
-		}
-	}
 
-	/* reroute the edges from the original argument projs to the RegParam ones. */
-	for(i = 0; i < max_arg; ++i) {
-		if(args[i] != NULL) {
-			assert(args_repl[i] != NULL);
-			edges_reroute(args[i], args_repl[i], irg);
+			assert(repl != NULL);
+			edges_reroute(args[i], repl, irg);
 		}
 	}
 
@@ -1098,46 +1244,89 @@ static void modify_irg(be_abi_irg_t *env)
 		ir_node *irn = get_irn_n(end, i);
 
 		if(get_irn_opcode(irn) == iro_Return) {
-			ir_node *bl   = get_nodes_block(irn);
-			int n_res     = get_Return_n_ress(irn);
-			pmap *reg_map = pmap_create_ex(n_res);
+			ir_node *bl    = get_nodes_block(irn);
+			int n_res      = get_Return_n_ress(irn);
+			pmap *reg_map  = pmap_create();
+			ir_node *mem   = get_Return_mem(irn);
+			int in_max;
 			ir_node *ret;
 			int i, n;
 			ir_node **in;
+			const arch_register_t **regs;
 
-			/* collect all arguments of the return */
-			obstack_ptr_grow(&env->obst, get_Return_mem(irn));
+			pmap_insert(reg_map, (void *) sp, pmap_get(env->regs, (void *) sp));
+
+			/* Insert results for Return into the register map. */
 			for(i = 0; i < n_res; ++i) {
 				ir_node *res           = get_Return_res(irn, i);
 				be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
-
 				assert(arg->in_reg && "return value must be passed in register");
-				pmap_insert(reg_map, res, (void *) arg->reg);
-				obstack_ptr_grow(&env->obst, res);
+				pmap_insert(reg_map, (void *) arg->reg, res);
+			}
+
+			/* Add uses of the callee save registers. */
+			pmap_foreach(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);
+			}
+
+			/* Make the Epilogue node and call the arch's epilogue maker. */
+			create_barrier(env, bl, &mem, reg_map, 1);
+			call->cb->epilogue(env->cb, bl, &mem, reg_map);
+
+			/*
+				Maximum size of the in array for Return nodes is
+				return args + callee save/ignore registers + memory + stack pointer
+			*/
+			in_max = pmap_count(reg_map) + get_Return_n_ress(irn) + 2;
+
+			in   = obstack_alloc(&env->obst, in_max * sizeof(in[0]));
+			regs = obstack_alloc(&env->obst, in_max * sizeof(regs[0]));
+
+			in[0]   = mem;
+			in[1]   = be_abi_reg_map_get(reg_map, sp);
+			regs[0] = NULL;
+			regs[1] = sp;
+			n       = 2;
+
+			/* clear SP entry, since it has already been grown. */
+			pmap_insert(reg_map, (void *) sp, NULL);
+			for(i = 0; i < n_res; ++i) {
+				ir_node *res           = get_Return_res(irn, i);
+				be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
+
+				in[n]     = be_abi_reg_map_get(reg_map, arg->reg);
+				regs[n++] = arg->reg;
+
+				/* Clear the map entry to mark the register as processed. */
+				be_abi_reg_map_set(reg_map, arg->reg, NULL);
 			}
 
-			/* generate the clean up code and add additional parameters to the return. */
-			clearup_frame(env, irn, &env->obst);
+			/* grow the rest of the stuff. */
+			pmap_foreach(reg_map, ent) {
+				if(ent->value) {
+					in[n]     = ent->value;
+					regs[n++] = ent->key;
+				}
+			}
 
 			/* The in array for the new back end return is now ready. */
-			n   = obstack_object_size(&env->obst) / sizeof(in[0]);
-			in  = obstack_finish(&env->obst);
 			ret = be_new_Return(irg, bl, n, in);
 
-			/* Set the constraints for some arguments of the return. */
-			for(i = 0; i < n; i++) {
-				const arch_register_t *reg = pmap_get(reg_map, in[i]);
-				if(reg != NULL)
-					be_set_constr_single_reg(ret, i, reg);
-			}
-			exchange(irn, ret);
+			/* Set the register classes of the return's parameter accordingly. */
+			for(i = 0; i < n; ++i)
+				if(regs[i])
+					be_node_set_reg_class(ret, i, regs[i]->reg_class);
+
+			/* Free the space of the Epilog's in array and the register <-> proj map. */
 			obstack_free(&env->obst, in);
+			exchange(irn, ret);
 			pmap_destroy(reg_map);
 		}
 	}
 
 	obstack_free(&env->obst, args);
-	be_abi_call_free(call);
 }
 
 /**
@@ -1152,12 +1341,15 @@ static void collect_alloca_walker(ir_node *irn, void *data)
 
 be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 {
-	be_abi_irg_t *env = malloc(sizeof(env[0]));
+	be_abi_irg_t *env  = xmalloc(sizeof(env[0]));
+	ir_node *old_frame = get_irg_frame(birg->irg);
+	ir_graph *irg      = birg->irg;
 
+	pmap_entry *ent;
 	ir_node *dummy;
 
 	env->isa           = birg->main_env->arch_env->isa;
-	env->method_type   = get_entity_type(get_irg_entity(birg->irg));
+	env->method_type   = get_entity_type(get_irg_entity(irg));
 	env->call          = be_abi_call_new();
 	arch_isa_get_call_abi(env->isa, env->method_type, env->call);
 
@@ -1165,7 +1357,9 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	env->birg             = birg;
 	env->dbg              = firm_dbg_register("firm.be.abi");
 	env->stack_phis       = pset_new_ptr(16);
-	env->init_sp = dummy  = new_r_Unknown(birg->irg, env->isa->sp->reg_class->mode);
+	env->init_sp = dummy  = new_r_Unknown(irg, env->isa->sp->reg_class->mode);
+
+	env->cb = env->call->cb->init(env->call, env->isa, irg);
 
 	obstack_init(&env->obst);
 
@@ -1179,14 +1373,18 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	modify_irg(env);
 
 	/* reroute the stack origin of the calls to the true stack origin. */
-	exchange(dummy, env->init_sp);
+	edges_reroute(dummy, env->init_sp, irg);
+	edges_reroute(old_frame, get_irg_frame(irg), irg);
 
 	/* Make some important node pointers survive the dead node elimination. */
 	survive_dce_register_irn(env->dce_survivor, &env->init_sp);
-	survive_dce_register_pmap(env->dce_survivor, env->regs);
+	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);
+	be_liveness(irg);
 	return env;
 }
 
@@ -1215,9 +1413,7 @@ static void collect_stack_nodes_walker(ir_node *irn, void *data)
 {
 	pset *s = data;
 
-	if((is_Proj(irn) && be_is_Alloca(get_Proj_pred(irn)) && get_Proj_proj(irn) == pn_Alloc_res)
-		|| be_is_IncSP(irn)
-		|| be_is_SetSP(irn))
+	if(be_is_AddSP(irn)	|| be_is_IncSP(irn)	|| be_is_SetSP(irn))
 		pset_insert_ptr(s, irn);
 }
 
@@ -1225,7 +1421,6 @@ void be_abi_fix_stack_nodes(be_abi_irg_t *env)
 {
 	dom_front_info_t *df;
 	pset *stack_nodes;
-	pmap_entry *ent;
 
 	/* We need dominance frontiers for fix up */
 	df = be_compute_dominance_frontiers(env->birg->irg);
@@ -1235,6 +1430,9 @@ void be_abi_fix_stack_nodes(be_abi_irg_t *env)
 	be_ssa_constr_set_phis(df, stack_nodes, env->stack_phis);
 	del_pset(stack_nodes);
 
+	/* Liveness could have changed due to Phi nodes. */
+	be_liveness(env->birg->irg);
+
 	/* free these dominance frontiers */
 	be_free_dominance_frontiers(df);
 }
@@ -1351,7 +1549,12 @@ ir_node *be_abi_get_callee_save_irn(be_abi_irg_t *abi, const arch_register_t *re
 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);
-	return is_Phi(irn) && pset_find_ptr(abi->stack_phis, (void *) irn) != NULL ? &abi->irn_ops : NULL;
+	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)
@@ -1366,10 +1569,20 @@ static const arch_register_req_t *abi_get_irn_reg_req(const void *self, arch_reg
 	be_abi_irg_t *abi          = get_abi_from_ops(self);
 	const arch_register_t *reg = abi->isa->sp;
 
-	req->cls         = reg->reg_class;
-	req->type        = arch_register_req_type_limited;
-	req->limited     = be_abi_limited;
-	req->limited_env = abi;
+	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;
 }