X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=a86183b154401078191b62022cc067fdedd9c11e;hb=c9b4f4105539e3980500c79e8e9a055e2c8c5173;hp=c2237d31872d288b11947df1753cc682cab3765a;hpb=194f0e40a79d0fc034f3f9cbd571e05f789c1614;p=libfirm

diff --git a/ir/be/beabi.c b/ir/be/beabi.c
index c2237d318..a86183b15 100644
--- a/ir/be/beabi.c
+++ b/ir/be/beabi.c
@@ -26,7 +26,6 @@
 #include "config.h"
 
 #include "obst.h"
-#include "offset.h"
 
 #include "irgopt.h"
 
@@ -39,7 +38,8 @@
 #include "irprintf_t.h"
 #include "irgopt.h"
 #include "irbitset.h"
-#include "height.h"
+#include "iropt_t.h"
+#include "heights.h"
 #include "pdeq.h"
 #include "irtools.h"
 #include "raw_bitset.h"
@@ -58,10 +58,11 @@
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg;)
 
-typedef struct _be_abi_call_arg_t {
+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. */
 	unsigned in_reg   : 1;  /**< 1: this argument is transmitted in registers. */
 	unsigned on_stack : 1;	/**< 1: this argument is transmitted on the stack. */
+	unsigned callee   : 1;  /**< 1: someone called us. 0: We call another function */
 
 	int                    pos;
 	const arch_register_t *reg;
@@ -72,7 +73,7 @@ typedef struct _be_abi_call_arg_t {
 	unsigned               space_after;  /**< allocate space after */
 } be_abi_call_arg_t;
 
-struct _be_abi_call_t {
+struct be_abi_call_t {
 	be_abi_call_flags_t          flags;  /**< Flags describing the ABI behavior on calls */
 	int                          pop;    /**< number of bytes the stack frame is shrinked by the callee on return. */
 	const be_abi_callbacks_t    *cb;
@@ -82,16 +83,12 @@ struct _be_abi_call_t {
 };
 
 /**
- * The ABI information for the current birg.
+ * The ABI information for the current graph.
  */
-struct _be_abi_irg_t {
-	be_irg_t             *birg;         /**< The back end IRG. */
-	ir_graph             *irg;
-	const arch_env_t     *arch_env;
+struct be_abi_irg_t {
 	survive_dce_t        *dce_survivor;
 
 	be_abi_call_t        *call;         /**< The ABI call information. */
-	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. */
@@ -108,20 +105,13 @@ struct _be_abi_irg_t {
 	pset                 *ignore_regs;  /**< Additional registers which shall be ignored. */
 
 	ir_node              **calls;       /**< flexible array containing all be_Call nodes */
-
-	arch_register_req_t  *sp_req;
-
-	be_stack_layout_t    frame;         /**< The stack frame model. */
 };
 
-static heights_t *ir_heights;
+static ir_heights_t *ir_heights;
 
 /** Flag: if set, try to omit the frame pointer in all routines. */
 static int be_omit_fp = 1;
 
-/** Flag: if set, try to omit the frame pointer in leaf routines only. */
-static int be_omit_leaf_fp = 1;
-
 /*
      _    ____ ___    ____      _ _ _                _
     / \  | __ )_ _|  / ___|__ _| | | |__   __ _  ___| | _____
@@ -140,7 +130,7 @@ 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);
+	return !(p->is_res == q->is_res && p->pos == q->pos && p->callee == q->callee);
 }
 
 /**
@@ -149,8 +139,9 @@ static int cmp_call_arg(const void *a, const void *b, size_t n)
  * @param call      the abi call
  * @param is_res    true for call results, false for call arguments
  * @param pos       position of the argument
+ * @param callee	context type - if we are callee or caller
  */
-static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos)
+static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos, int callee)
 {
 	be_abi_call_arg_t arg;
 	unsigned hash;
@@ -158,6 +149,7 @@ static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos)
 	memset(&arg, 0, sizeof(arg));
 	arg.is_res = is_res;
 	arg.pos    = pos;
+	arg.callee = callee;
 
 	hash = is_res * 128 + pos;
 
@@ -166,23 +158,18 @@ static be_abi_call_arg_t *get_call_arg(be_abi_call_t *call, int is_res, int pos)
 
 /**
  * Set an ABI call object argument.
- *
- * @param call      the abi call
- * @param is_res    true for call results, false for call arguments
- * @param pos       position of the argument
  */
-static be_abi_call_arg_t *create_call_arg(be_abi_call_t *call, int is_res, int pos)
+static void remember_call_arg(be_abi_call_arg_t *arg, be_abi_call_t *call, be_abi_context_t context)
 {
-	be_abi_call_arg_t arg;
-	unsigned hash;
-
-	memset(&arg, 0, sizeof(arg));
-	arg.is_res = is_res;
-	arg.pos    = pos;
-
-	hash = is_res * 128 + pos;
-
-	return set_insert(call->params, &arg, sizeof(arg), hash);
+	unsigned hash = arg->is_res * 128 + arg->pos;
+	if (context & ABI_CONTEXT_CALLEE) {
+		arg->callee = 1;
+		set_insert(call->params, arg, sizeof(*arg), hash);
+	}
+	if (context & ABI_CONTEXT_CALLER) {
+		arg->callee = 0;
+		set_insert(call->params, arg, sizeof(*arg), hash);
+	}
 }
 
 /* Set the flags for a call. */
@@ -206,29 +193,49 @@ 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, ir_mode *load_mode, 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_context_t context)
 {
-	be_abi_call_arg_t *arg = create_call_arg(call, 0, arg_pos);
-	arg->on_stack     = 1;
-	arg->load_mode    = load_mode;
-	arg->alignment    = alignment;
-	arg->space_before = space_before;
-	arg->space_after  = space_after;
+	be_abi_call_arg_t arg;
+	memset(&arg, 0, sizeof(arg));
 	assert(alignment > 0 && "Alignment must be greater than 0");
+	arg.on_stack     = 1;
+	arg.load_mode    = load_mode;
+	arg.alignment    = alignment;
+	arg.space_before = space_before;
+	arg.space_after  = space_after;
+	arg.is_res       = 0;
+	arg.pos          = arg_pos;
+
+	remember_call_arg(&arg, call, context);
 }
 
-void be_abi_call_param_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
+void be_abi_call_param_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg, be_abi_context_t context)
 {
-	be_abi_call_arg_t *arg = create_call_arg(call, 0, arg_pos);
-	arg->in_reg = 1;
-	arg->reg = reg;
+	be_abi_call_arg_t arg;
+	memset(&arg, 0, sizeof(arg));
+
+	arg.in_reg = 1;
+	arg.reg    = reg;
+	arg.is_res = 0;
+	arg.pos    = arg_pos;
+
+	remember_call_arg(&arg, call, context);
 }
 
-void be_abi_call_res_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg)
+void be_abi_call_res_reg(be_abi_call_t *call, int arg_pos, const arch_register_t *reg, be_abi_context_t context)
 {
-	be_abi_call_arg_t *arg = create_call_arg(call, 1, arg_pos);
-	arg->in_reg = 1;
-	arg->reg = reg;
+	be_abi_call_arg_t arg;
+	memset(&arg, 0, sizeof(arg));
+
+	arg.in_reg = 1;
+	arg.reg    = reg;
+	arg.is_res = 1;
+	arg.pos    = arg_pos;
+
+	remember_call_arg(&arg, call, context);
 }
 
 /* Get the flags of a ABI call object. */
@@ -253,7 +260,7 @@ static be_abi_call_t *be_abi_call_new(const arch_register_class_t *cls_addr)
 	call->cb         = NULL;
 	call->cls_addr   = cls_addr;
 
-	call->flags.bits.try_omit_fp = be_omit_fp | be_omit_leaf_fp;
+	call->flags.bits.try_omit_fp = be_omit_fp;
 
 	return call;
 }
@@ -267,79 +274,6 @@ static void be_abi_call_free(be_abi_call_t *call)
 	free(call);
 }
 
-/*
-  _____                           _   _                 _ _ _
- |  ___| __ __ _ _ __ ___   ___  | | | | __ _ _ __   __| | (_)_ __   __ _
- | |_ | '__/ _` | '_ ` _ \ / _ \ | |_| |/ _` | '_ \ / _` | | | '_ \ / _` |
- |  _|| | | (_| | | | | | |  __/ |  _  | (_| | | | | (_| | | | | | | (_| |
- |_|  |_|  \__,_|_| |_| |_|\___| |_| |_|\__,_|_| |_|\__,_|_|_|_| |_|\__, |
-                                                                    |___/
-
-  Handling of the stack frame. It is composed of three types:
-  1) The type of the arguments which are pushed on the stack.
-  2) The "between type" which consists of stuff the call of the
-     function pushes on the stack (like the return address and
-	 the old base pointer for ia32).
-  3) The Firm frame type which consists of all local variables
-     and the spills.
-*/
-
-static int get_stack_entity_offset(be_stack_layout_t *frame, ir_entity *ent,
-                                   int bias)
-{
-	ir_type *t = get_entity_owner(ent);
-	int ofs    = get_entity_offset(ent);
-
-	int index;
-
-	/* Find the type the entity is contained in. */
-	for (index = 0; index < N_FRAME_TYPES; ++index) {
-		if (frame->order[index] == t)
-			break;
-		/* Add the size of all the types below the one of the entity to the entity's offset */
-		ofs += get_type_size_bytes(frame->order[index]);
-	}
-
-	/* correct the offset by the initial position of the frame pointer */
-	ofs -= frame->initial_offset;
-
-	/* correct the offset with the current bias. */
-	ofs += bias;
-
-	return ofs;
-}
-
-/**
- * Retrieve the entity with given offset from a frame type.
- */
-static ir_entity *search_ent_with_offset(ir_type *t, int offset)
-{
-	int i, n;
-
-	for (i = 0, n = get_compound_n_members(t); i < n; ++i) {
-		ir_entity *ent = get_compound_member(t, i);
-		if (get_entity_offset(ent) == offset)
-			return ent;
-	}
-
-	return NULL;
-}
-
-static int stack_frame_compute_initial_offset(be_stack_layout_t *frame)
-{
-	ir_type  *base = frame->stack_dir < 0 ? frame->between_type : frame->frame_type;
-	ir_entity *ent = search_ent_with_offset(base, 0);
-
-	if (ent == NULL) {
-		frame->initial_offset
-			= frame->stack_dir < 0 ? get_type_size_bytes(frame->frame_type) : get_type_size_bytes(frame->between_type);
-	} else {
-		frame->initial_offset = get_stack_entity_offset(frame, ent, 0);
-	}
-
-	return frame->initial_offset;
-}
-
 /**
  * Initializes the frame layout from parts
  *
@@ -368,8 +302,7 @@ static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *ar
 	if (stack_dir > 0) {
 		frame->order[0] = args;
 		frame->order[2] = locals;
-	}
-	else {
+	} else {
 		/* typical decreasing stack: locals have the
 		 * lowest addresses, arguments the highest */
 		frame->order[0] = locals;
@@ -378,16 +311,6 @@ static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *ar
 	return frame;
 }
 
-/**
- * Returns non-zero if the call argument at given position
- * is transfered on the stack.
- */
-static inline int is_on_stack(be_abi_call_t *call, int pos)
-{
-	be_abi_call_arg_t *arg = get_call_arg(call, 0, pos);
-	return arg && !arg->in_reg;
-}
-
 /*
    ____      _ _
   / ___|__ _| | |___
@@ -409,8 +332,8 @@ 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_graph *irg              = env->birg->irg;
-	const arch_env_t *arch_env = env->birg->main_env->arch_env;
+	ir_graph *irg              = get_irn_irg(irn);
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
 	ir_type *call_tp           = get_Call_type(irn);
 	ir_node *call_ptr          = get_Call_ptr(irn);
 	int n_params               = get_method_n_params(call_tp);
@@ -421,7 +344,6 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	const arch_register_t *sp  = arch_env->sp;
 	be_abi_call_t *call        = be_abi_call_new(sp->reg_class);
 	ir_mode *mach_mode         = sp->reg_class->mode;
-	struct obstack *obst       = be_get_birg_obst(irg);
 	int no_alloc               = call->flags.bits.frame_is_setup_on_call;
 	int n_res                  = get_method_n_ress(call_tp);
 	int do_seq                 = call->flags.bits.store_args_sequential && !no_alloc;
@@ -431,31 +353,26 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	int n_stack_params = 0;
 	int n_ins;
 
-	pset_new_t              destroyed_regs, states;
-	pset_new_iterator_t     iter;
+	const arch_register_t **states = NEW_ARR_F(const arch_register_t*, 0);
+	const arch_register_t **destroyed_regs = NEW_ARR_F(const arch_register_t*, 0);
 	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;
 	int                    *stack_param_idx;
 	int                     i, n, destroy_all_regs;
 	dbg_info               *dbgi;
 
-	pset_new_init(&destroyed_regs);
-	pset_new_init(&states);
-
 	/* Let the isa fill out the abi description for that call node. */
 	arch_env_get_call_abi(arch_env, call_tp, call);
 
 	/* Insert code to put the stack arguments on the stack. */
 	assert(get_Call_n_params(irn) == n_params);
-	assert(obstack_object_size(obst) == 0);
 	stack_param_idx = ALLOCAN(int, n_params);
 	for (i = 0; i < n_params; ++i) {
-		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, i, 0);
 		assert(arg);
 		if (arg->on_stack) {
 			int arg_size = get_type_size_bytes(get_method_param_type(call_tp, i));
@@ -471,7 +388,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	/* Collect all arguments which are passed in registers. */
 	reg_param_idxs = ALLOCAN(int, n_params);
 	for (i = 0; i < n_params; ++i) {
-		be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, i, 0);
 		if (arg && arg->in_reg) {
 			reg_param_idxs[n_reg_params++] = i;
 		}
@@ -518,7 +435,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
 		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);
+			be_abi_call_arg_t *arg = get_call_arg(call, 0, p, 0);
 			ir_node *param         = get_Call_param(irn, p);
 			ir_node *addr          = curr_sp;
 			ir_node *mem           = NULL;
@@ -555,14 +472,14 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 				ir_node *store;
 				ir_node *mem_input = do_seq ? curr_mem : new_NoMem();
 				store = new_rd_Store(dbgi, bl, mem_input, addr, param, 0);
-				mem   = new_r_Proj(bl, store, mode_M, pn_Store_M);
+				mem   = new_r_Proj(store, mode_M, pn_Store_M);
 			} else {
 				/* Make a mem copy for compound arguments. */
 				ir_node *copy;
 
 				assert(mode_is_reference(get_irn_mode(param)));
 				copy = new_rd_CopyB(dbgi, bl, curr_mem, addr, param, param_type);
-				mem = new_r_Proj(bl, copy, mode_M, pn_CopyB_M_regular);
+				mem = new_r_Proj(copy, mode_M, pn_CopyB_M);
 			}
 
 			curr_ofs += param_size;
@@ -597,30 +514,34 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 			destroy_all_regs = 1;
 	}
 
-	/* Put caller save into the destroyed set and state registers in the states set */
+	/* Put caller save into the destroyed set and state registers in the states
+	 * set */
 	for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
 		unsigned j;
 		const arch_register_class_t *cls = arch_env_get_reg_class(arch_env, i);
 		for (j = 0; j < cls->n_regs; ++j) {
 			const arch_register_t *reg = arch_register_for_index(cls, j);
 
-			if (destroy_all_regs || arch_register_type_is(reg, caller_save)) {
-				if (! arch_register_type_is(reg, ignore))
-					pset_new_insert(&destroyed_regs, (void *) reg);
-			}
+			/* even if destroyed all is specified, neither SP nor FP are
+			 * destroyed (else bad things will happen) */
+			if (reg == arch_env->sp || reg == arch_env->bp)
+				continue;
+
 			if (arch_register_type_is(reg, state)) {
-				pset_new_insert(&destroyed_regs, (void*) reg);
-				pset_new_insert(&states, (void*) reg);
+				ARR_APP1(const arch_register_t*, destroyed_regs, reg);
+				ARR_APP1(const arch_register_t*, states, reg);
+				/* we're already in the destroyed set so no need for further
+				 * checking */
+				continue;
+			}
+			if (destroy_all_regs || arch_register_type_is(reg, caller_save)) {
+				if (! arch_register_type_is(reg, ignore)) {
+					ARR_APP1(const arch_register_t*, destroyed_regs, reg);
+				}
 			}
 		}
 	}
 
-	if (destroy_all_regs) {
-		/* even if destroyed all is specified, neither SP nor FP are destroyed (else bad things will happen) */
-		pset_new_remove(&destroyed_regs, arch_env->sp);
-		pset_new_remove(&destroyed_regs, arch_env->bp);
-	}
-
 	/* search the largest result proj number */
 	res_projs = ALLOCANZ(ir_node*, n_res);
 
@@ -651,9 +572,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	 */
 	n_reg_results = n_res;
 
-	assert(obstack_object_size(obst) == 0);
 	n_ins = 0;
-	in    = ALLOCAN(ir_node*, n_reg_params + pset_new_size(&states));
+	in    = ALLOCAN(ir_node*, n_reg_params + ARR_LEN(states));
 
 	/* make the back end call node and set its register requirements. */
 	for (i = 0; i < n_reg_params; ++i) {
@@ -661,7 +581,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	}
 
 	/* add state registers ins */
-	foreach_pset_new(&states, reg, iter) {
+	for (i = 0; i < ARR_LEN(states); ++i) {
+		const arch_register_t       *reg = states[i];
 		const arch_register_class_t *cls = arch_register_get_class(reg);
 #if 0
 		ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
@@ -670,19 +591,19 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		ir_node *regnode = new_r_Unknown(irg, arch_register_class_mode(cls));
 		in[n_ins++]      = regnode;
 	}
-	assert(n_ins == (int) (n_reg_params + pset_new_size(&states)));
+	assert(n_ins == (int) (n_reg_params + ARR_LEN(states)));
 
 	/* ins collected, build the call */
 	if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
 		/* direct call */
 		low_call = be_new_Call(dbgi, irg, bl, curr_mem, curr_sp, curr_sp,
-		                       n_reg_results + pn_be_Call_first_res + pset_new_size(&destroyed_regs),
+		                       n_reg_results + pn_be_Call_first_res + ARR_LEN(destroyed_regs),
 		                       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(dbgi, irg, bl, curr_mem, curr_sp, call_ptr,
-		                       n_reg_results + pn_be_Call_first_res + pset_new_size(&destroyed_regs),
+		                       n_reg_results + pn_be_Call_first_res + ARR_LEN(destroyed_regs),
 		                       n_ins, in, get_Call_type(irn));
 	}
 	be_Call_set_pop(low_call, call->pop);
@@ -691,7 +612,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	ARR_APP1(ir_node *, env->calls, low_call);
 
 	/* create new stack pointer */
-	curr_sp = new_r_Proj(bl, low_call, get_irn_mode(curr_sp), pn_be_Call_sp);
+	curr_sp = new_r_Proj(low_call, get_irn_mode(curr_sp), pn_be_Call_sp);
 	be_set_constr_single_reg_out(low_call, pn_be_Call_sp, sp,
 			arch_register_req_type_ignore | arch_register_req_type_produces_sp);
 	arch_set_irn_register(curr_sp, sp);
@@ -700,7 +621,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_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);
+		be_abi_call_arg_t *arg  = get_call_arg(call, 1, i, 0);
 
 		/* returns values on stack not supported yet */
 		assert(arg->in_reg);
@@ -715,7 +636,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		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(bl, low_call, mode, pn);
+			proj              = new_r_Proj(low_call, mode, pn);
 			res_projs[i]      = proj;
 		} else {
 			set_Proj_pred(proj, low_call);
@@ -723,7 +644,16 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		}
 
 		if (arg->in_reg) {
-			pset_new_remove(&destroyed_regs, arg->reg);
+			/* remove register from destroyed regs */
+			int j;
+			int n = ARR_LEN(destroyed_regs);
+			for (j = 0; j < n; ++j) {
+				if (destroyed_regs[j] == arg->reg) {
+					destroyed_regs[j] = destroyed_regs[n-1];
+					ARR_SHRINKLEN(destroyed_regs,n-1);
+					break;
+				}
+			}
 		}
 	}
 
@@ -738,7 +668,7 @@ 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_reg_params; ++i) {
 		int index = reg_param_idxs[i];
-		be_abi_call_arg_t *arg = get_call_arg(call, 0, index);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, index, 0);
 		assert(arg->reg != NULL);
 
 		be_set_constr_single_reg_in(low_call, be_pos_Call_first_arg + i,
@@ -748,7 +678,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	/* Set the register constraints of the results. */
 	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);
+		const be_abi_call_arg_t *arg  = get_call_arg(call, 1, i, 0);
 		int                      pn   = get_Proj_proj(proj);
 
 		assert(arg->in_reg);
@@ -765,23 +695,22 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 	/* Make additional projs for the caller save registers
 	   and the Keep node which keeps them alive. */
 	{
-		const arch_register_t *reg;
 		ir_node               **in, *keep;
 		int                   i;
 		int                   n = 0;
 		int                   curr_res_proj = pn_be_Call_first_res + n_reg_results;
-		pset_new_iterator_t   iter;
 		int                   n_ins;
 
-		n_ins = (int)pset_new_size(&destroyed_regs) + n_reg_results + 1;
+		n_ins = ARR_LEN(destroyed_regs) + n_reg_results + 1;
 		in    = ALLOCAN(ir_node *, n_ins);
 
 		/* also keep the stack pointer */
 		set_irn_link(curr_sp, (void*) sp);
 		in[n++] = curr_sp;
 
-		foreach_pset_new(&destroyed_regs, reg, iter) {
-			ir_node *proj = new_r_Proj(bl, low_call, reg->reg_class->mode, curr_res_proj);
+		for (i = 0; i < ARR_LEN(destroyed_regs); ++i) {
+			const arch_register_t *reg = destroyed_regs[i];
+			ir_node *proj = new_r_Proj(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_out(low_call, curr_res_proj, reg, 0);
@@ -824,7 +753,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 		}
 
 		if (! mem_proj) {
-			mem_proj = new_r_Proj(bl, low_call, mode_M, pn_be_Call_M_regular);
+			mem_proj = new_r_Proj(low_call, mode_M, pn_be_Call_M_regular);
 			keep_alive(mem_proj);
 		}
 	}
@@ -835,8 +764,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
 	be_abi_call_free(call);
 
-	pset_new_destroy(&states);
-	pset_new_destroy(&destroyed_regs);
+	DEL_ARR_F(states);
+	DEL_ARR_F(destroyed_regs);
 
 	return curr_sp;
 }
@@ -880,25 +809,24 @@ static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size,
  */
 static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
 {
-	ir_node *block;
-	ir_graph *irg;
-	ir_node *alloc_mem;
-	ir_node *alloc_res;
-	ir_type *type;
-	dbg_info *dbg;
+	ir_node          *block     = get_nodes_block(alloc);
+	ir_graph         *irg       = get_Block_irg(block);
+	const arch_env_t *arch_env  = be_get_irg_arch_env(irg);
+	ir_node          *alloc_mem = NULL;
+	ir_node          *alloc_res = NULL;
+	ir_type          *type      = get_Alloc_type(alloc);
+	dbg_info         *dbg;
 
 	const ir_edge_t *edge;
-	ir_node *new_alloc, *size, *addr, *ins[2];
+	ir_node *new_alloc;
+	ir_node *count;
+	ir_node *size;
+	ir_node *ins[2];
 	unsigned stack_alignment;
 
+	/* all non-stack Alloc nodes should already be lowered before the backend */
 	assert(get_Alloc_where(alloc) == stack_alloc);
 
-	block = get_nodes_block(alloc);
-	irg   = get_Block_irg(block);
-	alloc_mem = NULL;
-	alloc_res = NULL;
-	type = get_Alloc_type(alloc);
-
 	foreach_out_edge(alloc, edge) {
 		ir_node *irn = get_edge_src_irn(edge);
 
@@ -923,32 +851,34 @@ 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);
-	size = get_Alloc_size(alloc);
+	dbg   = get_irn_dbg_info(alloc);
+	count = get_Alloc_count(alloc);
 
-	/* we might need to multiply the size with the element size */
+	/* we might need to multiply the count with the element size */
 	if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
-		ir_mode *mode = get_irn_mode(size);
+		ir_mode *mode = get_irn_mode(count);
 		tarval *tv    = new_tarval_from_long(get_type_size_bytes(type),
 		                                     mode);
 		ir_node *cnst = new_rd_Const(dbg, irg, tv);
-		size          = new_rd_Mul(dbg, block, size, cnst, mode);
+		size          = new_rd_Mul(dbg, block, count, cnst, mode);
+	} else {
+		size = count;
 	}
 
 	/* The stack pointer will be modified in an unknown manner.
 	   We cannot omit it. */
 	env->call->flags.bits.try_omit_fp = 0;
 
-	stack_alignment = 1 << env->arch_env->stack_alignment;
+	stack_alignment = 1 << arch_env->stack_alignment;
 	size            = adjust_alloc_size(stack_alignment, size, block, dbg);
-	new_alloc       = be_new_AddSP(env->arch_env->sp, block, curr_sp, size);
+	new_alloc       = be_new_AddSP(arch_env->sp, block, curr_sp, size);
 	set_irn_dbg_info(new_alloc, dbg);
 
 	if (alloc_mem != NULL) {
 		ir_node *addsp_mem;
 		ir_node *sync;
 
-		addsp_mem = new_r_Proj(block, new_alloc, mode_M, pn_be_AddSP_M);
+		addsp_mem = new_r_Proj(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. */
@@ -964,9 +894,7 @@ 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    = alloc_res;
-	curr_sp = new_r_Proj(block, new_alloc,  get_irn_mode(curr_sp),
-	                     pn_be_AddSP_sp);
+	curr_sp = new_r_Proj(new_alloc,  get_irn_mode(curr_sp), pn_be_AddSP_sp);
 
 	return curr_sp;
 }
@@ -977,23 +905,20 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp
  */
 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 *subsp, *mem, *res, *size, *sync;
-	ir_type *type;
+	ir_node          *block    = get_nodes_block(free);
+	ir_graph         *irg      = get_irn_irg(free);
+	ir_type          *type     = get_Free_type(free);
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
+	ir_mode          *sp_mode  = arch_env->sp->reg_class->mode;
+	dbg_info         *dbg      = get_irn_dbg_info(free);
+	ir_node  *subsp, *mem, *res, *size, *sync;
 	ir_node *in[2];
-	ir_mode *sp_mode;
 	unsigned stack_alignment;
-	dbg_info *dbg;
 
+	/* all non-stack-alloc Free nodes should already be lowered before the
+	 * backend phase */
 	assert(get_Free_where(free) == stack_alloc);
 
-	block = get_nodes_block(free);
-	irg = get_irn_irg(block);
-	type = get_Free_type(free);
-	sp_mode = env->arch_env->sp->reg_class->mode;
-	dbg = get_irn_dbg_info(free);
-
 	/* we might need to multiply the size with the element size */
 	if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
 		tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
@@ -1005,17 +930,17 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
 		size = get_Free_size(free);
 	}
 
-	stack_alignment = 1 << env->arch_env->stack_alignment;
+	stack_alignment = 1 << arch_env->stack_alignment;
 	size            = adjust_alloc_size(stack_alignment, size, block, dbg);
 
 	/* The stack pointer will be modified in an unknown manner.
 	   We cannot omit it. */
 	env->call->flags.bits.try_omit_fp = 0;
-	subsp = be_new_SubSP(env->arch_env->sp, block, curr_sp, size);
+	subsp = be_new_SubSP(arch_env->sp, block, curr_sp, size);
 	set_irn_dbg_info(subsp, dbg);
 
-	mem = new_r_Proj(block, subsp, mode_M, pn_be_SubSP_M);
-	res = new_r_Proj(block, subsp, sp_mode, pn_be_SubSP_sp);
+	mem = new_r_Proj(subsp, mode_M, pn_be_SubSP_M);
+	res = new_r_Proj(subsp, sp_mode, pn_be_SubSP_sp);
 
 	/* we need to sync the memory */
 	in[0] = get_Free_mem(free);
@@ -1157,7 +1082,6 @@ static void process_ops_in_block(ir_node *bl, void *data)
 				break;
 			default:
 				panic("invalid call");
-				break;
 			}
 		}
 
@@ -1177,15 +1101,15 @@ static void process_ops_in_block(ir_node *bl, void *data)
 /**
  * Adjust all call nodes in the graph to the ABI conventions.
  */
-static void process_calls(be_abi_irg_t *env)
+static void process_calls(ir_graph *irg)
 {
-	ir_graph *irg = env->birg->irg;
+	be_abi_irg_t *abi = be_get_irg_abi(irg);
 
-	env->call->flags.bits.irg_is_leaf = 1;
-	irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, env);
+	abi->call->flags.bits.irg_is_leaf = 1;
+	irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, abi);
 
-	ir_heights = heights_new(env->birg->irg);
-	irg_block_walk_graph(irg, NULL, process_ops_in_block, env);
+	ir_heights = heights_new(irg);
+	irg_block_walk_graph(irg, NULL, process_ops_in_block, abi);
 	heights_free(ir_heights);
 }
 
@@ -1202,28 +1126,30 @@ static void process_calls(be_abi_irg_t *env)
  *
  * @return the stack argument layout type
  */
-static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call,
+static ir_type *compute_arg_type(be_abi_irg_t *env, ir_graph *irg,
+                                 be_abi_call_t *call,
 								 ir_type *method_type, ir_type *val_param_tp,
 								 ir_entity ***param_map)
 {
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
 	int dir  = env->call->flags.bits.left_to_right ? 1 : -1;
-	int inc  = env->birg->main_env->arch_env->stack_dir * dir;
+	int inc  = arch_env->stack_dir * dir;
 	int n    = get_method_n_params(method_type);
 	int curr = inc > 0 ? 0 : n - 1;
-	struct obstack *obst = be_get_birg_obst(env->irg);
+	struct obstack *obst = be_get_be_obst(irg);
 	int ofs  = 0;
 
 	char buf[128];
 	ir_type *res;
 	int i;
-	ident *id = get_entity_ident(get_irg_entity(env->birg->irg));
+	ident *id = get_entity_ident(get_irg_entity(irg));
 	ir_entity **map;
 
 	*param_map = map = OALLOCN(obst, ir_entity*, n);
 	res = new_type_struct(id_mangle_u(id, new_id_from_chars("arg_type", 8)));
 	for (i = 0; i < n; ++i, curr += inc) {
 		ir_type *param_type    = get_method_param_type(method_type, curr);
-		be_abi_call_arg_t *arg = get_call_arg(call, 0, curr);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, curr, 1);
 
 		map[i] = NULL;
 		if (arg->on_stack) {
@@ -1325,7 +1251,7 @@ static ir_node *create_barrier(ir_node *bl, ir_node **mem, pmap *regs,
 				add_type |= arch_register_req_type_produces_sp;
 		}
 
-		proj = new_r_Proj(bl, irn, get_irn_mode(pred), n);
+		proj = new_r_Proj(irn, get_irn_mode(pred), n);
 		be_node_set_reg_class_in(irn, n, reg->reg_class);
 		if (in_req)
 			be_set_constr_single_reg_in(irn, n, reg, 0);
@@ -1336,7 +1262,7 @@ static ir_node *create_barrier(ir_node *bl, ir_node **mem, pmap *regs,
 	}
 
 	if (mem) {
-		*mem = new_r_Proj(bl, irn, mode_M, n);
+		*mem = new_r_Proj(irn, mode_M, n);
 	}
 
 	return irn;
@@ -1355,7 +1281,8 @@ 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_env_t *arch_env = env->birg->main_env->arch_env;
+	ir_graph         *irg      = get_Block_irg(bl);
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
 	dbg_info *dbgi;
 	pmap *reg_map  = pmap_create();
 	ir_node *keep  = pmap_get(env->keep_map, bl);
@@ -1379,13 +1306,13 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
 	if (keep) {
 		stack = get_irn_n(keep, 0);
 		kill_node(keep);
-		remove_End_keepalive(get_irg_end(env->birg->irg), keep);
+		remove_End_keepalive(get_irg_end(irg), keep);
 	}
 
 	/* 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);
+		be_abi_call_arg_t *arg = get_call_arg(call, 1, i, 1);
 		assert(arg->in_reg && "return value must be passed in register");
 		pmap_insert(reg_map, (void *) arg->reg, res);
 	}
@@ -1421,7 +1348,7 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
 	/* clear SP entry, since it has already been grown. */
 	pmap_insert(reg_map, (void *) arch_env->sp, NULL);
 	for (i = 0; i < n_res; ++i) {
-		be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
+		be_abi_call_arg_t *arg = get_call_arg(call, 1, i, 1);
 
 		in[n]     = be_abi_reg_map_get(reg_map, arg->reg);
 		regs[n++] = arg->reg;
@@ -1446,7 +1373,7 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
 	}
 	/* 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);
+	ret = be_new_Return(dbgi, irg, bl, n_res, pop, n, in);
 
 	/* Set the register classes of the return's parameter accordingly. */
 	for (i = 0; i < n; ++i) {
@@ -1569,10 +1496,11 @@ static void lower_frame_sels_walker(ir_node *irn, void *data)
  * In the default case we move the entity to the frame type and create
  * a backing store into the first block.
  */
-static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *value_param_list)
+static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_graph *irg,
+                                            ent_pos_pair *value_param_list)
 {
-	be_abi_call_t *call = env->call;
-	ir_graph      *irg  = env->birg->irg;
+	be_abi_call_t    *call     = env->call;
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
 	ent_pos_pair  *entry, *new_list;
 	ir_type       *frame_tp;
 	int           i, n = ARR_LEN(value_param_list);
@@ -1580,7 +1508,7 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 	new_list = NULL;
 	for (i = 0; i < n; ++i) {
 		int               pos  = value_param_list[i].pos;
-		be_abi_call_arg_t *arg = get_call_arg(call, 0, pos);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, pos, 1);
 
 		if (arg->in_reg) {
 			DBG((dbg, LEVEL_2, "\targ #%d need backing store\n", pos));
@@ -1591,16 +1519,11 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 	if (new_list != NULL) {
 		/* ok, change the graph */
 		ir_node *start_bl = get_irg_start_block(irg);
-		ir_node *first_bl = NULL;
-		ir_node *frame, *imem, *nmem, *store, *mem, *args, *args_bl;
-		const ir_edge_t *edge;
+		ir_node *first_bl = get_first_block_succ(start_bl);
+		ir_node *frame, *imem, *nmem, *store, *mem, *args;
 		optimization_state_t state;
 		unsigned offset;
 
-		foreach_block_succ(start_bl, edge) {
-			first_bl = get_edge_src_irn(edge);
-			break;
-		}
 		assert(first_bl && first_bl != start_bl);
 		/* we had already removed critical edges, so the following
 		   assertion should be always true. */
@@ -1612,7 +1535,7 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 
 		save_optimization_state(&state);
 		set_optimize(0);
-		nmem = new_r_Proj(start_bl, get_irg_start(irg), mode_M, pn_Start_M);
+		nmem = new_r_Proj(get_irg_start(irg), mode_M, pn_Start_M);
 		restore_optimization_state(&state);
 
 		/* reroute all edges to the new memory source */
@@ -1621,7 +1544,6 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 		store   = NULL;
 		mem     = imem;
 		args    = get_irg_args(irg);
-		args_bl = get_nodes_block(args);
 		for (entry = new_list; entry != NULL; entry = entry->next) {
 			int     i     = entry->pos;
 			ir_type *tp   = get_entity_type(entry->ent);
@@ -1629,14 +1551,14 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 			ir_node *addr;
 
 			/* address for the backing store */
-			addr = be_new_FrameAddr(env->arch_env->sp->reg_class, first_bl, frame, entry->ent);
+			addr = be_new_FrameAddr(arch_env->sp->reg_class, first_bl, frame, entry->ent);
 
 			if (store)
-				mem = new_r_Proj(first_bl, store, mode_M, pn_Store_M);
+				mem = new_r_Proj(store, mode_M, pn_Store_M);
 
 			/* the backing store itself */
 			store = new_r_Store(first_bl, mem, addr,
-			                    new_r_Proj(args_bl, args, mode, i), 0);
+			                    new_r_Proj(args, mode, i), 0);
 		}
 		/* the new memory Proj gets the last Proj from store */
 		set_Proj_pred(nmem, store);
@@ -1652,9 +1574,10 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 		for (entry = new_list; entry != NULL; entry = entry->next) {
 			ir_entity *ent = entry->ent;
 
-			/* If the entity is still on the argument type, move it to the frame type.
-			   This happens if the value_param type was build due to compound
-			   params. */
+			/* If the entity is still on the argument type, move it to the
+			 * frame type.
+			 * This happens if the value_param type was build due to compound
+			 * params. */
 			if (get_entity_owner(ent) != frame_tp) {
 				ir_type  *tp   = get_entity_type(ent);
 				unsigned align = get_type_alignment_bytes(tp);
@@ -1662,7 +1585,6 @@ static void fix_address_of_parameter_access(be_abi_irg_t *env, ent_pos_pair *val
 				offset += align - 1;
 				offset &= ~(align - 1);
 				set_entity_owner(ent, frame_tp);
-				add_class_member(frame_tp, ent);
 				/* must be automatic to set a fixed layout */
 				set_entity_offset(ent, offset);
 				offset += get_type_size_bytes(tp);
@@ -1774,18 +1696,19 @@ static void fix_outer_variable_access(be_abi_irg_t *env,
 /**
  * Modify the irg itself and the frame type.
  */
-static void modify_irg(be_abi_irg_t *env)
+static void modify_irg(ir_graph *irg)
 {
-	be_abi_call_t *call       = env->call;
-	const arch_env_t *arch_env= env->birg->main_env->arch_env;
-	const arch_register_t *sp = arch_env->sp;
-	ir_graph *irg             = env->birg->irg;
+	be_abi_irg_t          *env          = be_get_irg_abi(irg);
+	be_abi_call_t         *call         = env->call;
+	const arch_env_t      *arch_env     = be_get_irg_arch_env(irg);
+	const arch_register_t *sp           = arch_env->sp;
+	ir_type               *method_type  = get_entity_type(get_irg_entity(irg));
+	struct obstack        *obst         = be_get_be_obst(irg);
+	be_stack_layout_t     *stack_layout = be_get_irg_stack_layout(irg);
 	ir_node *end;
 	ir_node *old_mem;
 	ir_node *new_mem_proj;
 	ir_node *mem;
-	ir_type *method_type      = get_entity_type(get_irg_entity(irg));
-	struct obstack *obst      = be_get_birg_obst(irg);
 
 	int n_params;
 	int i, n;
@@ -1824,13 +1747,13 @@ static void modify_irg(be_abi_irg_t *env)
 		}
 	}
 
-	arg_type = compute_arg_type(env, call, method_type, tp, &param_map);
+	arg_type = compute_arg_type(env, irg, call, method_type, tp, &param_map);
 
 	/* Convert the Sel nodes in the irg to frame addr nodes: */
 	ctx.value_param_list = NEW_ARR_F(ent_pos_pair, 0);
 	ctx.frame            = get_irg_frame(irg);
-	ctx.sp_class         = env->arch_env->sp->reg_class;
-	ctx.link_class       = env->arch_env->link_class;
+	ctx.sp_class         = arch_env->sp->reg_class;
+	ctx.link_class       = arch_env->link_class;
 	ctx.frame_tp         = get_irg_frame_type(irg);
 
 	/* layout the stackframe now */
@@ -1872,7 +1795,7 @@ static void modify_irg(be_abi_irg_t *env)
 	 * In the default case we move the entity to the frame type and create
 	 * a backing store into the first block.
 	 */
-	fix_address_of_parameter_access(env, ctx.value_param_list);
+	fix_address_of_parameter_access(env, irg, ctx.value_param_list);
 
 	DEL_ARR_F(ctx.value_param_list);
 	irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK);
@@ -1889,11 +1812,13 @@ static void modify_irg(be_abi_irg_t *env)
 	}
 
 	bet_type = call->cb->get_between_type(env->cb);
-	stack_frame_init(&env->frame, arg_type, bet_type, get_irg_frame_type(irg), arch_env->stack_dir, param_map);
+	stack_frame_init(stack_layout, arg_type, bet_type,
+	                 get_irg_frame_type(irg), arch_env->stack_dir, param_map);
+	stack_layout->sp_relative = call->flags.bits.try_omit_fp;
 
 	/* 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);
+		be_abi_call_arg_t *arg = get_call_arg(call, 0, i, 1);
 		if (arg->in_reg && args[i]) {
 			assert(arg->reg != sp && "cannot use stack pointer as parameter register");
 			assert(i == get_Proj_proj(args[i]));
@@ -1945,7 +1870,7 @@ static void modify_irg(be_abi_irg_t *env)
 			add_type |= arch_register_req_type_produces_sp | arch_register_req_type_ignore;
 
 		assert(nr >= 0);
-		proj = new_r_Proj(start_bl, env->start, mode, nr + 1);
+		proj = new_r_Proj(env->start, mode, nr + 1);
 		pmap_insert(env->regs, (void *) reg, proj);
 		be_set_constr_single_reg_out(env->start, nr + 1, reg, add_type);
 		arch_set_irn_register(proj, reg);
@@ -1956,12 +1881,12 @@ static void modify_irg(be_abi_irg_t *env)
 	/* create a new initial memory proj */
 	assert(is_Proj(old_mem));
 	arch_set_out_register_req(env->start, 0, arch_no_register_req);
-	new_mem_proj = new_r_Proj(start_bl, env->start, mode_M, 0);
+	new_mem_proj = new_r_Proj(env->start, mode_M, 0);
 	mem = new_mem_proj;
 	set_irg_initial_mem(irg, mem);
 
 	/* Generate the Prologue */
-	fp_reg = call->cb->prologue(env->cb, &mem, env->regs, &env->frame.initial_bias);
+	fp_reg = call->cb->prologue(env->cb, &mem, env->regs, &stack_layout->initial_bias);
 
 	/* do the stack allocation BEFORE the barrier, or spill code
 	   might be added before it */
@@ -1998,7 +1923,7 @@ static void modify_irg(be_abi_irg_t *env)
 			ir_mode *mode;
 
 			nr         = MIN(nr, n_params);
-			arg        = get_call_arg(call, 0, nr);
+			arg        = get_call_arg(call, 0, nr, 1);
 			param_type = get_method_param_type(method_type, nr);
 
 			if (arg->in_reg) {
@@ -2012,7 +1937,7 @@ static void modify_irg(be_abi_irg_t *env)
 					ir_mode *load_mode = arg->load_mode;
 
 					ir_node *load = new_r_Load(start_bl, new_NoMem(), addr, load_mode, cons_floats);
-					repl = new_r_Proj(start_bl, load, load_mode, pn_Load_res);
+					repl = new_r_Proj(load, load_mode, pn_Load_res);
 
 					if (mode != load_mode) {
 						repl = new_r_Conv(start_bl, repl, mode);
@@ -2060,10 +1985,10 @@ static void modify_irg(be_abi_irg_t *env)
 }
 
 /** Fix the state inputs of calls that still hang on unknowns */
-static
-void fix_call_state_inputs(be_abi_irg_t *env)
+static void fix_call_state_inputs(ir_graph *irg)
 {
-	const arch_env_t *arch_env = env->arch_env;
+	be_abi_irg_t     *env      = be_get_irg_abi(irg);
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
 	int i, n, n_states;
 	arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0);
 
@@ -2167,19 +2092,27 @@ static int can_address_relative(ir_entity *entity)
 		&& !(get_entity_linkage(entity) & IR_LINKAGE_MERGE);
 }
 
+static ir_node *get_pic_base(ir_graph *irg)
+{
+	const arch_env_t *arch_env = be_get_irg_arch_env(irg);
+	if (arch_env->impl->get_pic_base == NULL)
+		return NULL;
+	return arch_env->impl->get_pic_base(irg);
+}
+
 /** patches SymConsts to work in position independent code */
 static void fix_pic_symconsts(ir_node *node, void *data)
 {
-	ir_graph     *irg;
-	ir_node      *pic_base;
-	ir_node      *add;
-	ir_node      *block;
-	ir_mode      *mode;
-	ir_node      *load;
-	ir_node      *load_res;
-	be_abi_irg_t *env = data;
-	int           arity, i;
-	be_main_env_t *be = env->birg->main_env;
+	ir_graph         *irg = get_irn_irg(node);
+	be_main_env_t    *be  = be_get_irg_main_env(irg);
+	ir_node          *pic_base;
+	ir_node          *add;
+	ir_node          *block;
+	ir_mode          *mode;
+	ir_node          *load;
+	ir_node          *load_res;
+	int               arity, i;
+	(void) data;
 
 	arity = get_irn_arity(node);
 	for (i = 0; i < arity; ++i) {
@@ -2194,7 +2127,6 @@ static void fix_pic_symconsts(ir_node *node, void *data)
 
 		entity = get_SymConst_entity(pred);
 		block  = get_nodes_block(pred);
-		irg    = get_irn_irg(pred);
 
 		/* calls can jump to relative addresses, so we can directly jump to
 		   the (relatively) known call address or the trampoline */
@@ -2215,7 +2147,7 @@ static void fix_pic_symconsts(ir_node *node, void *data)
 
 		/* everything else is accessed relative to EIP */
 		mode     = get_irn_mode(pred);
-		pic_base = arch_code_generator_get_pic_base(env->birg->cg);
+		pic_base = get_pic_base(irg);
 
 		/* all ok now for locally constructed stuff */
 		if (can_address_relative(entity)) {
@@ -2231,7 +2163,7 @@ static void fix_pic_symconsts(ir_node *node, void *data)
 		dbgi         = get_irn_dbg_info(pred);
 		pic_symbol   = get_pic_symbol(be, entity);
 		pic_symconst = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code,
- 		                                        pic_symbol, NULL);
+		                                        pic_symbol, NULL);
 		add = new_r_Add(block, pic_base, pic_symconst, mode);
 		mark_irn_visited(add);
 
@@ -2239,76 +2171,62 @@ static void fix_pic_symconsts(ir_node *node, void *data)
 		   module. The loads are always safe and can therefore float
 		   and need no memory input */
 		load     = new_r_Load(block, new_NoMem(), add, mode, cons_floats);
-		load_res = new_r_Proj(block, load, mode, pn_Load_res);
+		load_res = new_r_Proj(load, mode, pn_Load_res);
 
 		set_irn_n(node, i, load_res);
 	}
 }
 
-be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
+be_abi_irg_t *be_abi_introduce(ir_graph *irg)
 {
-	be_abi_irg_t *env  = XMALLOC(be_abi_irg_t);
-	ir_node *old_frame = get_irg_frame(birg->irg);
-	ir_graph *irg      = birg->irg;
-	struct obstack *obst = be_get_birg_obst(irg);
+	be_abi_irg_t     *env         = XMALLOCZ(be_abi_irg_t);
+	ir_node          *old_frame   = get_irg_frame(irg);
+	be_options_t     *options     = be_get_irg_options(irg);
+	const arch_env_t *arch_env    = be_get_irg_arch_env(irg);
+	ir_entity        *entity      = get_irg_entity(irg);
+	ir_type          *method_type = get_entity_type(entity);
 
 	pmap_entry *ent;
 	ir_node *dummy;
-	unsigned *limited_bitset;
-	arch_register_req_t *sp_req;
-
-	be_omit_fp      = birg->main_env->options->omit_fp;
-	be_omit_leaf_fp = birg->main_env->options->omit_leaf_fp;
-
-	obstack_init(obst);
-
-	env->arch_env    = birg->main_env->arch_env;
-	env->method_type = get_entity_type(get_irg_entity(irg));
-	env->call        = be_abi_call_new(env->arch_env->sp->reg_class);
-	arch_env_get_call_abi(env->arch_env, 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->irg          = irg;
 
-	sp_req = OALLOCZ(obst, arch_register_req_t);
-	env->sp_req = sp_req;
-
-	sp_req->type = arch_register_req_type_limited
-	             | arch_register_req_type_produces_sp;
-	sp_req->cls  = arch_register_get_class(env->arch_env->sp);
+	/* break here if backend provides a custom API.
+	 * Note: we shouldn't have to setup any be_abi_irg_t* stuff at all,
+	 * but need more cleanup to make this work
+	 */
+	be_set_irg_abi(irg, env);
+	if (arch_env->custom_abi)
+		return env;
 
-	limited_bitset = rbitset_obstack_alloc(obst, sp_req->cls->n_regs);
-	rbitset_set(limited_bitset, arch_register_get_index(env->arch_env->sp));
-	sp_req->limited = limited_bitset;
-	if (env->arch_env->sp->type & arch_register_type_ignore) {
-		sp_req->type |= arch_register_req_type_ignore;
-	}
+	be_omit_fp      = options->omit_fp;
 
-	env->init_sp = dummy = new_r_Dummy(irg, env->arch_env->sp->reg_class->mode);
+	env->dce_survivor = new_survive_dce();
+	env->keep_map     = pmap_create();
+	env->call         = be_abi_call_new(arch_env->sp->reg_class);
+	arch_env_get_call_abi(arch_env, method_type, env->call);
 
-	env->calls = NEW_ARR_F(ir_node*, 0);
+	env->init_sp = dummy = new_r_Dummy(irg, arch_env->sp->reg_class->mode);
+	env->calls   = NEW_ARR_F(ir_node*, 0);
 
-	if (birg->main_env->options->pic) {
+	if (options->pic) {
 		irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
 	}
 
 	/* Lower all call nodes in the IRG. */
-	process_calls(env);
+	process_calls(irg);
 
 	/*
 		Beware: init backend abi call object after processing calls,
 		otherwise some information might be not yet available.
 	*/
-	env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg);
+	env->cb = env->call->cb->init(env->call, irg);
 
 	/* Process the IRG */
-	modify_irg(env);
+	modify_irg(irg);
 
 	/* fix call inputs for state registers */
-	fix_call_state_inputs(env);
+	fix_call_state_inputs(irg);
 
 	/* We don't need the keep map anymore. */
 	pmap_destroy(env->keep_map);
@@ -2333,13 +2251,21 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
 	return env;
 }
 
-void be_abi_free(be_abi_irg_t *env)
+void be_abi_free(ir_graph *irg)
 {
-	be_abi_call_free(env->call);
-	free_survive_dce(env->dce_survivor);
-	del_pset(env->ignore_regs);
-	pmap_destroy(env->regs);
+	be_abi_irg_t *env = be_get_irg_abi(irg);
+
+	if (env->call != NULL)
+		be_abi_call_free(env->call);
+	if (env->dce_survivor != NULL)
+		free_survive_dce(env->dce_survivor);
+	if (env->ignore_regs != NULL)
+		del_pset(env->ignore_regs);
+	if (env->regs != NULL)
+		pmap_destroy(env->regs);
 	free(env);
+
+	be_set_irg_abi(irg, NULL);
 }
 
 void be_abi_put_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls, bitset_t *bs)
@@ -2372,271 +2298,6 @@ void be_abi_set_non_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *
 	}
 }
 
-/* Returns the stack layout from a abi environment. */
-const be_stack_layout_t *be_abi_get_stack_layout(const be_abi_irg_t *abi)
-{
-	return &abi->frame;
-}
-
-/*
-
-  _____ _        ____  _             _
- |  ___(_)_  __ / ___|| |_ __ _  ___| | __
- | |_  | \ \/ / \___ \| __/ _` |/ __| |/ /
- |  _| | |>  <   ___) | || (_| | (__|   <
- |_|   |_/_/\_\ |____/ \__\__,_|\___|_|\_\
-
-*/
-
-typedef ir_node **node_array;
-
-typedef struct fix_stack_walker_env_t {
-	node_array sp_nodes;
-} fix_stack_walker_env_t;
-
-/**
- * Walker. Collect all stack modifying nodes.
- */
-static void collect_stack_nodes_walker(ir_node *node, void *data)
-{
-	ir_node                   *insn = node;
-	fix_stack_walker_env_t    *env = data;
-	const arch_register_req_t *req;
-
-	if (is_Proj(node)) {
-		insn = get_Proj_pred(node);
-	}
-
-	if (arch_irn_get_n_outs(insn) == 0)
-		return;
-
-	req = arch_get_register_req_out(node);
-	if (! (req->type & arch_register_req_type_produces_sp))
-		return;
-
-	ARR_APP1(ir_node*, env->sp_nodes, node);
-}
-
-void be_abi_fix_stack_nodes(be_abi_irg_t *env)
-{
-	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;
-
-	walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0);
-
-	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;
-	}
-
-	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));
-
-	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(phi, env->sp_req);
-		arch_set_irn_register(phi, env->arch_env->sp);
-	}
-	be_ssa_construction_destroy(&senv);
-
-	DEL_ARR_F(walker_env.sp_nodes);
-}
-
-/**
- * Fix all stack accessing operations in the block bl.
- *
- * @param env        the abi environment
- * @param bl         the block to process
- * @param real_bias  the bias value
- *
- * @return the bias at the end of this block
- */
-static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int real_bias)
-{
-	int               omit_fp  = env->call->flags.bits.try_omit_fp;
-	ir_node          *irn;
-	int               wanted_bias = real_bias;
-
-	sched_foreach(bl, irn) {
-		int ofs;
-
-		/*
-		   Check, if the node relates to an entity on the stack frame.
-		   If so, set the true offset (including the bias) for that
-		   node.
-		 */
-		ir_entity *ent = arch_get_frame_entity(irn);
-		if (ent != NULL) {
-			int bias   = omit_fp ? real_bias : 0;
-			int offset = get_stack_entity_offset(&env->frame, ent, bias);
-			arch_set_frame_offset(irn, offset);
-			DBG((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.
-		 */
-		ofs = arch_get_sp_bias(irn);
-
-		if (be_is_IncSP(irn)) {
-			/* fill in real stack frame size */
-			if (ofs == BE_STACK_FRAME_SIZE_EXPAND) {
-				ir_type *frame_type = get_irg_frame_type(env->birg->irg);
-				ofs = (int) get_type_size_bytes(frame_type);
-				be_set_IncSP_offset(irn, ofs);
-			} else if (ofs == BE_STACK_FRAME_SIZE_SHRINK) {
-				ir_type *frame_type = get_irg_frame_type(env->birg->irg);
-				ofs = - (int)get_type_size_bytes(frame_type);
-				be_set_IncSP_offset(irn, ofs);
-			} else {
-				if (be_get_IncSP_align(irn)) {
-					/* patch IncSP to produce an aligned stack pointer */
-					ir_type *between_type = env->frame.between_type;
-					int      between_size = get_type_size_bytes(between_type);
-					int      alignment    = 1 << env->arch_env->stack_alignment;
-					int      delta        = (real_bias + ofs + between_size) & (alignment - 1);
-					assert(ofs >= 0);
-					if (delta > 0) {
-						be_set_IncSP_offset(irn, ofs + alignment - delta);
-						real_bias += alignment - delta;
-					}
-				} else {
-					/* adjust so real_bias corresponds with wanted_bias */
-					int delta = wanted_bias - real_bias;
-					assert(delta <= 0);
-					if (delta != 0) {
-						be_set_IncSP_offset(irn, ofs + delta);
-						real_bias += delta;
-					}
-				}
-			}
-		}
-
-		real_bias   += ofs;
-		wanted_bias += ofs;
-	}
-
-	assert(real_bias == wanted_bias);
-	return real_bias;
-}
-
-/**
- * A helper struct for the bias walker.
- */
-struct bias_walk {
-	be_abi_irg_t *env;     /**< The ABI irg environment. */
-	int           start_block_bias;  /**< The bias at the end of the start block. */
-	int           between_size;
-	ir_node      *start_block;  /**< The start block of the current graph. */
-};
-
-/**
- * Block-Walker: fix all stack offsets for all blocks
- * except the start block
- */
-static void stack_bias_walker(ir_node *bl, void *data)
-{
-	struct bias_walk *bw = data;
-	if (bl != bw->start_block) {
-		process_stack_bias(bw->env, bl, bw->start_block_bias);
-	}
-}
-
-/**
- * Walker: finally lower all Sels of outer frame or parameter
- * entities.
- */
-static void lower_outer_frame_sels(ir_node *sel, void *ctx)
-{
-	be_abi_irg_t *env = ctx;
-	ir_node      *ptr;
-	ir_entity    *ent;
-	ir_type      *owner;
-
-	if (! is_Sel(sel))
-		return;
-
-	ent   = get_Sel_entity(sel);
-	owner = get_entity_owner(ent);
-	ptr   = get_Sel_ptr(sel);
-
-	if (owner == env->frame.frame_type || owner == env->frame.arg_type) {
-		/* found access to outer frame or arguments */
-		int offset = get_stack_entity_offset(&env->frame, ent, 0);
-
-		if (offset != 0) {
-			ir_node  *bl   = get_nodes_block(sel);
-			dbg_info *dbgi = get_irn_dbg_info(sel);
-			ir_mode  *mode = get_irn_mode(sel);
-			ir_mode  *mode_UInt = get_reference_mode_unsigned_eq(mode);
-			ir_node  *cnst = new_r_Const_long(current_ir_graph, mode_UInt, offset);
-
-			ptr = new_rd_Add(dbgi, bl, ptr, cnst, mode);
-		}
-		exchange(sel, ptr);
-	}
-}
-
-void be_abi_fix_stack_bias(be_abi_irg_t *env)
-{
-	ir_graph          *irg = env->birg->irg;
-	ir_type           *frame_tp;
-	int               i;
-	struct bias_walk  bw;
-
-	stack_frame_compute_initial_offset(&env->frame);
-	// stack_layout_dump(stdout, frame);
-
-	/* Determine the stack bias at the end of the start block. */
-	bw.start_block_bias = process_stack_bias(env, get_irg_start_block(irg), env->frame.initial_bias);
-	bw.between_size     = get_type_size_bytes(env->frame.between_type);
-
-	/* fix the bias is all other blocks */
-	bw.env = env;
-	bw.start_block = get_irg_start_block(irg);
-	irg_block_walk_graph(irg, stack_bias_walker, NULL, &bw);
-
-	/* fix now inner functions: these still have Sel node to outer
-	   frame and parameter entities */
-	frame_tp = get_irg_frame_type(irg);
-	for (i = get_class_n_members(frame_tp) - 1; i >= 0; --i) {
-		ir_entity *ent = get_class_member(frame_tp, i);
-		ir_graph  *irg = get_entity_irg(ent);
-
-		if (irg != NULL) {
-			irg_walk_graph(irg, NULL, lower_outer_frame_sels, env);
-		}
-	}
-}
-
 ir_node *be_abi_get_callee_save_irn(be_abi_irg_t *abi, const arch_register_t *reg)
 {
 	assert(arch_register_type_is(reg, callee_save));
@@ -2651,18 +2312,8 @@ ir_node *be_abi_get_ignore_irn(be_abi_irg_t *abi, const arch_register_t *reg)
 	return pmap_get(abi->regs, (void *) reg);
 }
 
-/**
- * Returns non-zero if the ABI has omitted the frame pointer in
- * the current graph.
- */
-int be_abi_omit_fp(const be_abi_irg_t *abi)
-{
-	return abi->call->flags.bits.try_omit_fp;
-}
-
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_abi);
 void be_init_abi(void)
 {
 	FIRM_DBG_REGISTER(dbg, "firm.be.abi");
 }
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_abi);