remove has_compound_ret_parameter, we already had cc_compound_ret
[libfirm] / ir / be / beabi.c
index e7cbdd4..a71e41a 100644 (file)
@@ -95,7 +95,6 @@ struct be_abi_irg_t {
        ir_node              *start;        /**< The be_Start params node. */
        pmap                 *regs;         /**< A map of all callee-save and ignore regs to
                                                 their Projs to the RegParams node. */
-
        int                  start_block_bias; /**< The stack bias at the end of the start block. */
 
        pmap                 *keep_map;     /**< mapping blocks to keep nodes. */
@@ -108,6 +107,43 @@ static ir_heights_t *ir_heights;
 /** Flag: if set, try to omit the frame pointer in all routines. */
 static int be_omit_fp = 1;
 
+static ir_node *be_abi_reg_map_get(pmap *map, const arch_register_t *reg)
+{
+       return (ir_node*)pmap_get(map, reg);
+}
+
+static void be_abi_reg_map_set(pmap *map, const arch_register_t* reg,
+                               ir_node *node)
+{
+       pmap_insert(map, reg, node);
+}
+
+/**
+ * Check if the given register is callee save, ie. will be saved by the callee.
+ */
+static bool arch_register_is_callee_save(
+       const arch_env_t      *arch_env,
+       const arch_register_t *reg)
+{
+       if (arch_env->impl->register_saved_by)
+               return arch_env->impl->register_saved_by(reg, /*callee=*/1);
+       return false;
+}
+
+/**
+ * Check if the given register is caller save, ie. must be saved by the caller.
+ */
+static bool arch_register_is_caller_save(
+       const arch_env_t      *arch_env,
+       const arch_register_t *reg)
+{
+       if (arch_env->impl->register_saved_by)
+               return arch_env->impl->register_saved_by(reg, /*callee=*/0);
+       return false;
+}
+
+
+
 /*
      _    ____ ___    ____      _ _ _                _
     / \  | __ )_ _|  / ___|__ _| | | |__   __ _  ___| | _____
@@ -352,6 +388,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
        int                    *reg_param_idxs;
        int                    *stack_param_idx;
        int                     i, n, destroy_all_regs;
+       int                     throws_exception;
        size_t                  s;
        size_t                  p;
        dbg_info               *dbgi;
@@ -405,12 +442,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
                ir_node **in       = ALLOCAN(ir_node*, n_stack_params+1);
                unsigned  n_in     = 0;
 
-               /*
-                * Reverse list of stack parameters if call arguments are from left to right.
-                * We must them reverse again if they are pushed (not stored) and the stack
-                * direction is downwards.
-                */
-               if (call->flags.bits.left_to_right ^ do_seq) {
+               /* push params in reverse direction because stack grows downwards */
+               if (do_seq) {
                        for (i = 0; i < n_stack_params >> 1; ++i) {
                                int other  = n_stack_params - i - 1;
                                int tmp    = stack_param_idx[i];
@@ -460,7 +493,8 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
                        /* Insert a store for primitive arguments. */
                        if (is_atomic_type(param_type)) {
-                               ir_node *mem_input = do_seq ? curr_mem : new_r_NoMem(irg);
+                               ir_node *nomem     = get_irg_no_mem(irg);
+                               ir_node *mem_input = do_seq ? curr_mem : nomem;
                                ir_node *store     = new_rd_Store(dbgi, bl, mem_input, addr, param, cons_none);
                                mem   = new_r_Proj(store, mode_M, pn_Store_M);
                        } else {
@@ -524,7 +558,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
                                 * checking */
                                continue;
                        }
-                       if (destroy_all_regs || (reg->type & arch_register_type_caller_save)) {
+                       if (destroy_all_regs || arch_register_is_caller_save(arch_env, reg)) {
                                if (!(reg->type & arch_register_type_ignore)) {
                                        ARR_APP1(const arch_register_t*, destroyed_regs, reg);
                                }
@@ -573,17 +607,14 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
        /* add state registers ins */
        for (s = 0; s < ARR_LEN(states); ++s) {
                const arch_register_t       *reg = states[s];
-               const arch_register_class_t *cls = arch_register_get_class(reg);
-#if 0
-               ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
-               ir_fprintf(stderr, "Adding %+F\n", regnode);
-#endif
-               ir_node *regnode = new_r_Unknown(irg, arch_register_class_mode(cls));
+               const arch_register_class_t *cls = reg->reg_class;
+               ir_node *regnode = new_r_Unknown(irg, cls->mode);
                in[n_ins++]      = regnode;
        }
        assert(n_ins == (int) (n_reg_params + ARR_LEN(states)));
 
        /* ins collected, build the call */
+       throws_exception = ir_throws_exception(irn);
        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,
@@ -596,6 +627,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
                                       n_reg_results + pn_be_Call_first_res + ARR_LEN(destroyed_regs),
                                       n_ins, in, get_Call_type(irn));
        }
+       ir_set_throws_exception(low_call, throws_exception);
        be_Call_set_pop(low_call, call->pop);
 
        /* put the call into the list of all calls for later processing */
@@ -609,9 +641,9 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 
        /* now handle results */
        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, 0);
+               long               pn   = i + pn_be_Call_first_res;
 
                /* returns values on stack not supported yet */
                assert(arg->in_reg);
@@ -726,7 +758,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
                keep = be_new_Keep(bl, n, in);
                for (i = 0; i < n; ++i) {
                        const arch_register_t *reg = (const arch_register_t*)get_irn_link(in[i]);
-                       be_node_set_reg_class_in(keep, i, reg->reg_class);
+                       be_node_set_reg_class_in(keep, i, arch_register_get_class(reg));
                }
        }
 
@@ -746,7 +778,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(low_call, mode_M, pn_be_Call_M_regular);
+                       mem_proj = new_r_Proj(low_call, mode_M, pn_be_Call_M);
                        keep_alive(mem_proj);
                }
        }
@@ -916,11 +948,11 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
        if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
                ir_tarval *tv   = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
                ir_node   *cnst = new_rd_Const(dbg, irg, tv);
-               ir_node   *mul  = new_rd_Mul(dbg, block, get_Free_size(free),
+               ir_node   *mul  = new_rd_Mul(dbg, block, get_Free_count(free),
                                             cnst, mode_Iu);
                size = mul;
        } else {
-               size = get_Free_size(free);
+               size = get_Free_count(free);
        }
 
        stack_alignment = 1 << arch_env->stack_alignment;
@@ -1123,61 +1155,86 @@ static void process_calls(ir_graph *irg)
  * Changes a possibly allocated value param type by moving
  * entities to the stack layout type.
  *
- * @param env           the ABI environment
  * @param call          the current call ABI
  * @param method_type   the method type
- * @param val_param_tp  the value parameter type, will be destroyed
- * @param param_map     an array mapping method arguments to the stack layout type
+ * @param param_map     an array mapping method arguments to the stack layout
+ *                      type
  *
  * @return the stack argument layout type
  */
-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)
+static ir_type *compute_arg_type(ir_graph *irg, be_abi_call_t *call,
+                                                                ir_type *method_type, ir_entity ***param_map)
 {
-       int dir  = env->call->flags.bits.left_to_right ? 1 : -1;
-       int inc  = -dir;
-       int n    = get_method_n_params(method_type);
-       int curr = inc > 0 ? 0 : n - 1;
        struct obstack *obst = be_get_be_obst(irg);
-       int ofs  = 0;
+       ir_type   *frame_type      = get_irg_frame_type(irg);
+       size_t     n_params        = get_method_n_params(method_type);
+       size_t     n_frame_members = get_compound_n_members(frame_type);
+       ir_entity *va_start_entity = NULL;
+       size_t   f;
+       int      ofs  = 0;
 
-       char buf[128];
        ir_type *res;
-       int i;
-       ident *id = get_entity_ident(get_irg_entity(irg));
+       size_t i;
        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, 1);
+       *param_map = map = OALLOCNZ(obst, ir_entity*, n_params);
+       res = new_type_struct(new_id_from_chars("arg_type", 8));
 
-               map[i] = NULL;
-               if (arg->on_stack) {
-                       if (val_param_tp != NULL) {
-                               /* the entity was already created, create a copy in the param type */
-                               ir_entity *val_ent = get_method_value_param_ent(method_type, i);
-                               arg->stack_ent = copy_entity_own(val_ent, res);
-                               set_entity_link(val_ent, arg->stack_ent);
-                               set_entity_link(arg->stack_ent, NULL);
-                       } else {
-                               /* create a new entity */
-                               snprintf(buf, sizeof(buf), "param_%d", i);
-                               arg->stack_ent = new_entity(res, new_id_from_str(buf), param_type);
-                       }
-                       ofs += arg->space_before;
-                       ofs = round_up2(ofs, arg->alignment);
-                       set_entity_offset(arg->stack_ent, ofs);
-                       ofs += arg->space_after;
-                       ofs += get_type_size_bytes(param_type);
-                       map[i] = arg->stack_ent;
+       /* collect existing entities for value_param_types */
+       for (f = n_frame_members; f > 0; ) {
+               ir_entity *entity = get_compound_member(frame_type, --f);
+               size_t     num;
+
+               set_entity_link(entity, NULL);
+               if (!is_parameter_entity(entity))
+                       continue;
+               num = get_entity_parameter_number(entity);
+               if (num == IR_VA_START_PARAMETER_NUMBER) {
+                       /* move entity to new arg_type */
+                       set_entity_owner(entity, res);
+                       va_start_entity = entity;
+                       continue;
+               }
+               assert(num < n_params);
+               if (map[num] != NULL)
+                       panic("multiple entities for parameter %u in %+F found", f, irg);
+
+               if (num != n_params && !get_call_arg(call, 0, num, 1)->on_stack) {
+                       /* don't move this entity */
+                       continue;
                }
+
+               map[num] = entity;
+               /* move entity to new arg_type */
+               set_entity_owner(entity, res);
+       }
+
+       for (i = 0; i < n_params; ++i) {
+               be_abi_call_arg_t *arg        = get_call_arg(call, 0, i, 1);
+               ir_type           *param_type = get_method_param_type(method_type, i);
+               ir_entity         *entity;
+
+               if (!arg->on_stack) {
+                       continue;
+               }
+               entity = map[i];
+               if (entity == NULL) {
+                       /* create a new entity */
+                       entity = new_parameter_entity(res, i, param_type);
+               }
+               ofs += arg->space_before;
+               ofs = round_up2(ofs, arg->alignment);
+               set_entity_offset(entity, ofs);
+               ofs += arg->space_after;
+               ofs += get_type_size_bytes(param_type);
+               arg->stack_ent = entity;
+       }
+       if (va_start_entity != NULL) {
+               set_entity_offset(va_start_entity, ofs);
        }
        set_type_size_bytes(res, ofs);
        set_type_state(res, layout_fixed);
+
        return res;
 }
 
@@ -1264,7 +1321,7 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
        /* Add uses of the callee save registers. */
        foreach_pmap(env->regs, ent) {
                const arch_register_t *reg = (const arch_register_t*)ent->key;
-               if (reg->type & (arch_register_type_callee_save | arch_register_type_ignore))
+               if ((reg->type & arch_register_type_ignore) || arch_register_is_callee_save(arch_env, reg))
                        pmap_insert(reg_map, ent->key, ent->value);
        }
 
@@ -1329,57 +1386,14 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
        return ret;
 }
 
-typedef struct ent_pos_pair ent_pos_pair;
-struct ent_pos_pair {
-       ir_entity    *ent;   /**< a value param entity */
-       int          pos;    /**< its parameter number */
-       ent_pos_pair *next;  /**< for linking */
-};
-
 typedef struct lower_frame_sels_env_t {
-       ent_pos_pair *value_param_list;          /**< the list of all value param entities */
        ir_node      *frame;                     /**< the current frame */
        const arch_register_class_t *sp_class;   /**< register class of the stack pointer */
        const arch_register_class_t *link_class; /**< register class of the link pointer */
-       ir_type      *value_tp;                  /**< the value type if any */
        ir_type      *frame_tp;                  /**< the frame type */
        int          static_link_pos;            /**< argument number of the hidden static link */
 } lower_frame_sels_env_t;
 
-/**
- * Return an entity from the backend for an value param entity.
- *
- * @param ent  an value param type entity
- * @param ctx  context
- */
-static ir_entity *get_argument_entity(ir_entity *ent, lower_frame_sels_env_t *ctx)
-{
-       ir_entity *argument_ent = (ir_entity*)get_entity_link(ent);
-
-       if (argument_ent == NULL) {
-               /* we have NO argument entity yet: This is bad, as we will
-               * need one for backing store.
-               * Create one here.
-               */
-               ir_type *frame_tp = ctx->frame_tp;
-               unsigned offset   = get_type_size_bytes(frame_tp);
-               ir_type  *tp      = get_entity_type(ent);
-               unsigned align    = get_type_alignment_bytes(tp);
-
-               offset += align - 1;
-               offset &= ~(align - 1);
-
-               argument_ent = copy_entity_own(ent, frame_tp);
-
-               /* must be automatic to set a fixed layout */
-               set_entity_offset(argument_ent, offset);
-               offset += get_type_size_bytes(tp);
-
-               set_type_size_bytes(frame_tp, offset);
-               set_entity_link(ent, argument_ent);
-       }
-       return argument_ent;
-}
 /**
  * Walker: Replaces Sels of frame type and
  * value param type entities by FrameAddress.
@@ -1396,143 +1410,10 @@ static void lower_frame_sels_walker(ir_node *irn, void *data)
                        ir_entity    *ent = get_Sel_entity(irn);
                        ir_node      *bl  = get_nodes_block(irn);
                        ir_node      *nw;
-                       int          pos = 0;
-                       int          is_value_param = 0;
-
-                       if (get_entity_owner(ent) == ctx->value_tp) {
-                               is_value_param = 1;
-
-                               /* replace by its copy from the argument type */
-                               pos = get_struct_member_index(ctx->value_tp, ent);
-                               ent = get_argument_entity(ent, ctx);
-                       }
 
                        nw = be_new_FrameAddr(ctx->sp_class, bl, ctx->frame, ent);
                        exchange(irn, nw);
-
-                       /* check, if it's a param Sel and if have not seen this entity before */
-                       if (is_value_param && get_entity_link(ent) == NULL) {
-                               ent_pos_pair pair;
-
-                               pair.ent  = ent;
-                               pair.pos  = pos;
-                               pair.next = NULL;
-                               ARR_APP1(ent_pos_pair, ctx->value_param_list, pair);
-                               /* just a mark */
-                               set_entity_link(ent, ctx->value_param_list);
-                       }
-               }
-       }
-}
-
-/**
- * Check if a value parameter is transmitted as a register.
- * This might happen if the address of an parameter is taken which is
- * transmitted in registers.
- *
- * Note that on some architectures this case must be handled specially
- * because the place of the backing store is determined by their ABI.
- *
- * 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, ir_graph *irg,
-                                            ent_pos_pair *value_param_list)
-{
-       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);
-
-       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, 1);
-
-               if (arg->in_reg) {
-                       DBG((dbg, LEVEL_2, "\targ #%d need backing store\n", pos));
-                       value_param_list[i].next = new_list;
-                       new_list = &value_param_list[i];
-               }
-       }
-       if (new_list != NULL) {
-               /* ok, change the graph */
-               ir_node *start_bl = get_irg_start_block(irg);
-               ir_node *first_bl = get_first_block_succ(start_bl);
-               ir_node *frame, *imem, *nmem, *store, *mem, *args;
-               optimization_state_t state;
-               unsigned offset;
-
-               assert(first_bl && first_bl != start_bl);
-               /* we had already removed critical edges, so the following
-                  assertion should be always true. */
-               assert(get_Block_n_cfgpreds(first_bl) == 1);
-
-               /* now create backing stores */
-               frame = get_irg_frame(irg);
-               imem = get_irg_initial_mem(irg);
-
-               save_optimization_state(&state);
-               set_optimize(0);
-               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 */
-               edges_reroute(imem, nmem);
-
-               store   = NULL;
-               mem     = imem;
-               args    = get_irg_args(irg);
-               for (entry = new_list; entry != NULL; entry = entry->next) {
-                       int     i     = entry->pos;
-                       ir_type *tp   = get_entity_type(entry->ent);
-                       ir_mode *mode = get_type_mode(tp);
-                       ir_node *addr;
-
-                       /* address for the backing store */
-                       addr = be_new_FrameAddr(arch_env->sp->reg_class, first_bl, frame, entry->ent);
-
-                       if (store)
-                               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, mode, i), cons_none);
-               }
-               /* the new memory Proj gets the last Proj from store */
-               set_Proj_pred(nmem, store);
-               set_Proj_proj(nmem, pn_Store_M);
-
-               /* move all entities to the frame type */
-               frame_tp = get_irg_frame_type(irg);
-               offset   = get_type_size_bytes(frame_tp);
-
-               /* we will add new entities: set the layout to undefined */
-               assert(get_type_state(frame_tp) == layout_fixed);
-               set_type_state(frame_tp, layout_undefined);
-               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 (get_entity_owner(ent) != frame_tp) {
-                               ir_type  *tp   = get_entity_type(ent);
-                               unsigned align = get_type_alignment_bytes(tp);
-
-                               offset += align - 1;
-                               offset &= ~(align - 1);
-                               set_entity_owner(ent, frame_tp);
-                               /* must be automatic to set a fixed layout */
-                               set_entity_offset(ent, offset);
-                               offset += get_type_size_bytes(tp);
-                       }
                }
-               set_type_size_bytes(frame_tp, offset);
-               /* fix the layout again */
-               set_type_state(frame_tp, layout_fixed);
        }
 }
 
@@ -1549,75 +1430,21 @@ static void fix_start_block(ir_graph *irg)
 
        assert(is_Proj(initial_X));
        exchange(initial_X, jmp);
-       set_irg_initial_exec(irg, new_r_Bad(irg));
-}
-
-/**
- * Update the entity of Sels to the outer value parameters.
- */
-static void update_outer_frame_sels(ir_node *irn, void *env)
-{
-       lower_frame_sels_env_t *ctx = (lower_frame_sels_env_t*)env;
-       ir_node                *ptr;
-       ir_entity              *ent;
-       int                    pos = 0;
-
-       if (! is_Sel(irn))
-               return;
-       ptr = get_Sel_ptr(irn);
-       if (! is_arg_Proj(ptr))
-               return;
-       if (get_Proj_proj(ptr) != ctx->static_link_pos)
-               return;
-       ent   = get_Sel_entity(irn);
-
-       if (get_entity_owner(ent) == ctx->value_tp) {
-               /* replace by its copy from the argument type */
-               pos = get_struct_member_index(ctx->value_tp, ent);
-               ent = get_argument_entity(ent, ctx);
-               set_Sel_entity(irn, ent);
-
-               /* check, if we have not seen this entity before */
-               if (get_entity_link(ent) == NULL) {
-                       ent_pos_pair pair;
-
-                       pair.ent  = ent;
-                       pair.pos  = pos;
-                       pair.next = NULL;
-                       ARR_APP1(ent_pos_pair, ctx->value_param_list, pair);
-                       /* just a mark */
-                       set_entity_link(ent, ctx->value_param_list);
-               }
-       }
-}
-
-/**
- * Fix access to outer local variables.
- */
-static void fix_outer_variable_access(be_abi_irg_t *env,
-                                      lower_frame_sels_env_t *ctx)
-{
-       int      i;
-       ir_graph *irg;
-       (void) env;
-
-       for (i = get_class_n_members(ctx->frame_tp) - 1; i >= 0; --i) {
-               ir_entity *ent = get_class_member(ctx->frame_tp, i);
-
-               if (! is_method_entity(ent))
-                       continue;
-
-               irg = get_entity_irg(ent);
-               if (irg == NULL)
-                       continue;
+       set_irg_initial_exec(irg, new_r_Bad(irg, mode_X));
 
-               /*
-                * FIXME: find the number of the static link parameter
-                * for now we assume 0 here
-                */
-               ctx->static_link_pos = 0;
+       /* merge start block with successor if possible */
+       {
+               const ir_edge_t *edge;
+               foreach_out_edge(jmp, edge) {
+                       ir_node *succ = get_edge_src_irn(edge);
+                       if (!is_Block(succ))
+                               continue;
 
-               irg_walk_graph(irg, NULL, update_outer_frame_sels, ctx);
+                       if (get_irn_arity(succ) == 1) {
+                               exchange(succ, start_block);
+                       }
+                       break;
+               }
        }
 }
 
@@ -1651,7 +1478,7 @@ static void modify_irg(ir_graph *irg)
        ir_node **args;
        ir_node *arg_tuple;
        const ir_edge_t *edge;
-       ir_type *arg_type, *bet_type, *tp;
+       ir_type *arg_type, *bet_type;
        lower_frame_sels_env_t ctx;
        ir_entity **param_map;
 
@@ -1659,25 +1486,11 @@ static void modify_irg(ir_graph *irg)
 
        old_mem = get_irg_initial_mem(irg);
 
-       irp_reserve_resources(irp, IR_RESOURCE_ENTITY_LINK);
-
-       /* set the links of all frame entities to NULL, we use it
-          to detect if an entity is already linked in the value_param_list */
-       tp = get_method_value_param_type(method_type);
-       ctx.value_tp = tp;
-       if (tp != NULL) {
-               /* clear the links of the clone type, let the
-                  original entities point to its clones */
-               for (i = get_struct_n_members(tp) - 1; i >= 0; --i) {
-                       ir_entity *mem  = get_struct_member(tp, i);
-                       set_entity_link(mem, NULL);
-               }
-       }
+       irp_reserve_resources(irp, IRP_RESOURCE_ENTITY_LINK);
 
-       arg_type = compute_arg_type(env, irg, call, method_type, tp, &param_map);
+       arg_type = compute_arg_type(irg, call, method_type, &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         = arch_env->sp->reg_class;
        ctx.link_class       = arch_env->link_class;
@@ -1688,14 +1501,6 @@ static void modify_irg(ir_graph *irg)
                default_layout_compound_type(ctx.frame_tp);
        }
 
-       /* we will possible add new entities to the frame: set the layout to undefined */
-       assert(get_type_state(ctx.frame_tp) == layout_fixed);
-       set_type_state(ctx.frame_tp, layout_undefined);
-
-       irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
-
-       /* fix the frame type layout again */
-       set_type_state(ctx.frame_tp, layout_fixed);
        /* align stackframe to 4 byte */
        frame_size = get_type_size_bytes(ctx.frame_tp);
        if (frame_size % 4 != 0) {
@@ -1707,25 +1512,11 @@ static void modify_irg(ir_graph *irg)
        n_params = get_method_n_params(method_type);
        args     = OALLOCNZ(obst, ir_node*, n_params);
 
-       /*
-        * for inner function we must now fix access to outer frame entities.
-        */
-       fix_outer_variable_access(env, &ctx);
+       be_add_parameter_entity_stores(irg);
 
-       /* Check if a value parameter is transmitted as a register.
-        * This might happen if the address of an parameter is taken which is
-        * transmitted in registers.
-        *
-        * Note that on some architectures this case must be handled specially
-        * because the place of the backing store is determined by their ABI.
-        *
-        * 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, irg, ctx.value_param_list);
+       irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
 
-       DEL_ARR_F(ctx.value_param_list);
-       irp_free_resources(irp, IR_RESOURCE_ENTITY_LINK);
+       irp_free_resources(irp, IRP_RESOURCE_ENTITY_LINK);
 
        /* Fill the argument vector */
        arg_tuple = get_irg_args(irg);
@@ -1761,7 +1552,7 @@ static void modify_irg(ir_graph *irg)
                const arch_register_class_t *cls = &arch_env->register_classes[i];
                for (j = 0; j < cls->n_regs; ++j) {
                        const arch_register_t *reg = &cls->regs[j];
-                       if (reg->type & (arch_register_type_callee_save | arch_register_type_state)) {
+                       if ((reg->type & arch_register_type_state) || arch_register_is_callee_save(arch_env, reg)) {
                                pmap_insert(env->regs, (void *) reg, NULL);
                        }
                }
@@ -1812,7 +1603,7 @@ static void modify_irg(ir_graph *irg)
 
        /* create a new initial memory proj */
        assert(is_Proj(old_mem));
-       arch_set_out_register_req(env->start, 0, arch_no_register_req);
+       arch_set_irn_register_req_out(env->start, 0, arch_no_register_req);
        new_mem_proj = new_r_Proj(env->start, mode_M, 0);
        mem = new_mem_proj;
        set_irg_initial_mem(irg, mem);
@@ -1855,8 +1646,9 @@ static void modify_irg(ir_graph *irg)
                                if (is_atomic_type(param_type) && get_irn_n_edges(args[i]) > 0) {
                                        ir_mode *mode      = get_type_mode(param_type);
                                        ir_mode *load_mode = arg->load_mode;
+                                       ir_node *nomem     = get_irg_no_mem(irg);
 
-                                       ir_node *load = new_r_Load(start_bl, new_r_NoMem(irg), addr, load_mode, cons_floats);
+                                       ir_node *load = new_r_Load(start_bl, nomem, addr, load_mode, cons_floats);
                                        repl = new_r_Proj(load, load_mode, pn_Load_res);
 
                                        if (mode != load_mode) {
@@ -1885,7 +1677,7 @@ static void modify_irg(ir_graph *irg)
        /* the arg proj is not needed anymore now and should be only used by the anchor */
        assert(get_irn_n_edges(arg_tuple) == 1);
        kill_node(arg_tuple);
-       set_irg_args(irg, new_r_Bad(irg));
+       set_irg_args(irg, new_r_Bad(irg, mode_T));
 
        /* All Return nodes hang on the End node, so look for them there. */
        end = get_irg_end_block(irg);
@@ -2090,14 +1882,14 @@ static void fix_pic_symconsts(ir_node *node, void *data)
                /* we need an extra indirection for global data outside our current
                   module. The loads are always safe and can therefore float
                   and need no memory input */
-               load     = new_r_Load(block, new_r_NoMem(irg), add, mode, cons_floats);
+               load     = new_r_Load(block, get_irg_no_mem(irg), add, mode, cons_floats);
                load_res = new_r_Proj(load, mode, pn_Load_res);
 
                set_irn_n(node, i, load_res);
        }
 }
 
-be_abi_irg_t *be_abi_introduce(ir_graph *irg)
+void be_abi_introduce(ir_graph *irg)
 {
        be_abi_irg_t     *env         = XMALLOCZ(be_abi_irg_t);
        ir_node          *old_frame   = get_irg_frame(irg);
@@ -2136,6 +1928,8 @@ be_abi_irg_t *be_abi_introduce(ir_graph *irg)
        env->init_sp = dummy;
        env->calls   = NEW_ARR_F(ir_node*, 0);
 
+       edges_assure(irg);
+
        if (options->pic) {
                irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
        }
@@ -2161,7 +1955,8 @@ be_abi_irg_t *be_abi_introduce(ir_graph *irg)
        exchange(dummy, env->init_sp);
        exchange(old_frame, get_irg_frame(irg));
 
-       return env;
+       pmap_destroy(env->regs);
+       env->regs = NULL;
 }
 
 void be_abi_free(ir_graph *irg)
@@ -2170,35 +1965,12 @@ void be_abi_free(ir_graph *irg)
 
        if (env->call != NULL)
                be_abi_call_free(env->call);
-       if (env->regs != NULL)
-               pmap_destroy(env->regs);
+       assert(env->regs == NULL);
        free(env);
 
        be_set_irg_abi(irg, NULL);
 }
 
-/**
- * called after nodes have been transformed so some node references can be
- * replaced with new nodes
- */
-void be_abi_transform_fixup(ir_graph *irg)
-{
-       be_abi_irg_t *abi = be_get_irg_abi(irg);
-       pmap         *new_regs;
-       pmap_entry   *entry;
-       if (abi == NULL || abi->regs == NULL)
-               return;
-
-       new_regs = pmap_create();
-       foreach_pmap(abi->regs, entry) {
-               ir_node *value       = (ir_node*)entry->value;
-               ir_node *transformed = be_transform_node(value);
-               pmap_insert(new_regs, entry->key, transformed);
-       }
-       pmap_destroy(abi->regs);
-       abi->regs = new_regs;
-}
-
 void be_put_allocatable_regs(const ir_graph *irg,
                              const arch_register_class_t *cls, bitset_t *bs)
 {
@@ -2239,22 +2011,7 @@ void be_set_allocatable_regs(const ir_graph *irg,
        }
 }
 
-ir_node *be_abi_get_callee_save_irn(ir_graph *irg, const arch_register_t *reg)
-{
-       const be_abi_irg_t *abi = be_get_irg_abi(irg);
-       assert(reg->type & arch_register_type_callee_save);
-       assert(pmap_contains(abi->regs, (void *) reg));
-       return (ir_node*)pmap_get(abi->regs, (void *) reg);
-}
-
-ir_node *be_abi_get_ignore_irn(ir_graph *irg, const arch_register_t *reg)
-{
-       const be_abi_irg_t *abi = be_get_irg_abi(irg);
-       assert(pmap_contains(abi->regs, (void *) reg));
-       return (ir_node*)pmap_get(abi->regs, (void *) reg);
-}
-
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_abi);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_abi)
 void be_init_abi(void)
 {
        FIRM_DBG_REGISTER(dbg, "firm.be.abi");