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);
}
*/
/**
- * Transform a call node.
+ * Transform a call node into a be_Call node.
+ *
* @param env The ABI environment for the current irg.
* @param irn The call node.
* @param curr_sp The stack pointer node to use.
*/
static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, ir_node *alloca_copy)
{
- ir_graph *irg = env->birg->irg;
+ ir_graph *irg = env->birg->irg;
const arch_env_t *arch_env = env->birg->main_env->arch_env;
- const arch_isa_t *isa = arch_env->isa;
- ir_type *mt = get_Call_type(irn);
- ir_node *call_ptr = get_Call_ptr(irn);
- int n_params = get_method_n_params(mt);
- ir_node *curr_mem = get_Call_mem(irn);
- ir_node *bl = get_nodes_block(irn);
- pset *results = pset_new_ptr(8);
- pset *caller_save = pset_new_ptr(8);
- pset *states = pset_new_ptr(2);
- int stack_size = 0;
- int stack_dir = arch_isa_stack_dir(isa);
- const arch_register_t *sp = arch_isa_sp(isa);
- be_abi_call_t *call = be_abi_call_new(sp->reg_class);
- ir_mode *mach_mode = sp->reg_class->mode;
- struct obstack *obst = &env->obst;
- int no_alloc = call->flags.bits.frame_is_setup_on_call;
-
- ir_node *res_proj = NULL;
- int curr_res_proj = pn_Call_max;
- int n_low_args = 0;
- int n_pos = 0;
- int count;
+ const arch_isa_t *isa = arch_env->isa;
+ ir_type *mt = get_Call_type(irn);
+ ir_node *call_ptr = get_Call_ptr(irn);
+ int n_params = get_method_n_params(mt);
+ ir_node *curr_mem = get_Call_mem(irn);
+ ir_node *bl = get_nodes_block(irn);
+ pset *results = pset_new_ptr(8);
+ pset *caller_save = pset_new_ptr(8);
+ pset *states = pset_new_ptr(2);
+ int stack_size = 0;
+ int stack_dir = arch_isa_stack_dir(isa);
+ const arch_register_t *sp = arch_isa_sp(isa);
+ be_abi_call_t *call = be_abi_call_new(sp->reg_class);
+ ir_mode *mach_mode = sp->reg_class->mode;
+ struct obstack *obst = &env->obst;
+ int no_alloc = call->flags.bits.frame_is_setup_on_call;
+
+ ir_node *res_proj = NULL;
+ int curr_res_proj = pn_Call_max;
+ int n_reg_params = 0;
+ int n_stack_params = 0;
+ int n_ins;
ir_node *low_call;
ir_node **in;
ir_node **res_projs;
const arch_register_t *reg;
const ir_edge_t *edge;
- int *low_args;
- int *pos;
+ int *reg_param_idxs;
+ int *stack_param_idx;
int i, n;
/* Let the isa fill out the abi description for that call node. */
/* Insert code to put the stack arguments on the stack. */
assert(get_Call_n_params(irn) == n_params);
- for(i = 0; i < n_params; ++i) {
+ for (i = 0; i < n_params; ++i) {
be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
assert(arg);
if (arg->on_stack) {
stack_size += round_up2(arg_size, arg->alignment);
stack_size += round_up2(arg->space_after, arg->alignment);
obstack_int_grow(obst, i);
- n_pos++;
+ ++n_stack_params;
}
}
- pos = obstack_finish(obst);
+ stack_param_idx = obstack_finish(obst);
/* Collect all arguments which are passed in registers. */
- for(i = 0, n = get_Call_n_params(irn); i < n; ++i) {
+ for (i = 0; i < n_params; ++i) {
be_abi_call_arg_t *arg = get_call_arg(call, 0, i);
- if(arg && arg->in_reg) {
+ if (arg && arg->in_reg) {
obstack_int_grow(obst, i);
- n_low_args++;
+ ++n_reg_params;
}
}
- low_args = obstack_finish(obst);
+ reg_param_idxs = obstack_finish(obst);
/* If there are some parameters which shall be passed on the stack. */
- if(n_pos > 0) {
+ if (n_stack_params > 0) {
int curr_ofs = 0;
int do_seq = call->flags.bits.store_args_sequential && !no_alloc;
* direction is downwards.
*/
if (call->flags.bits.left_to_right ^ (do_seq && stack_dir < 0)) {
- for (i = 0; i < n_pos >> 1; ++i) {
- int other = n_pos - i - 1;
- int tmp = pos[i];
- pos[i] = pos[other];
- pos[other] = tmp;
+ for (i = 0; i < n_stack_params >> 1; ++i) {
+ int other = n_stack_params - i - 1;
+ int tmp = stack_param_idx[i];
+ stack_param_idx[i] = stack_param_idx[other];
+ stack_param_idx[other] = tmp;
}
}
* we allocate as much space on the stack all parameters need, by
* moving the stack pointer along the stack's direction.
*/
- if(stack_dir < 0 && !do_seq && !no_alloc) {
+ if (stack_dir < 0 && !do_seq && !no_alloc) {
curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size);
- if(alloca_copy) {
+ if (alloca_copy) {
add_irn_dep(curr_sp, alloca_copy);
alloca_copy = NULL;
}
}
- if(!do_seq) {
+ if (! do_seq) {
obstack_ptr_grow(obst, get_Call_mem(irn));
curr_mem = new_NoMem();
} else {
curr_mem = get_Call_mem(irn);
}
- for(i = 0; i < n_pos; ++i) {
- int p = pos[i];
+ for (i = 0; i < n_stack_params; ++i) {
+ int p = stack_param_idx[i];
be_abi_call_arg_t *arg = get_call_arg(call, 0, p);
ir_node *param = get_Call_param(irn, p);
ir_node *addr = curr_sp;
if (do_seq) {
curr_ofs = 0;
addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before);
- if(alloca_copy) {
+ if (alloca_copy) {
add_irn_dep(curr_sp, alloca_copy);
alloca_copy = NULL;
}
curr_ofs = round_up2(curr_ofs, arg->alignment);
/* Make the expression to compute the argument's offset. */
- if(curr_ofs > 0) {
+ if (curr_ofs > 0) {
ir_mode *constmode = mach_mode;
if(mode_is_reference(mach_mode)) {
constmode = mode_Is;
in = (ir_node **) obstack_finish(obst);
/* We need the sync only, if we didn't build the stores sequentially. */
- if(!do_seq) {
- if(n_pos >= 1) {
- curr_mem = new_r_Sync(irg, bl, n_pos + 1, in);
+ if (! do_seq) {
+ if (n_stack_params >= 1) {
+ curr_mem = new_r_Sync(irg, bl, n_stack_params + 1, in);
} else {
curr_mem = get_Call_mem(irn);
}
}
/* Collect caller save registers */
- for(i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
+ for (i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
int j;
const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
- for(j = 0; j < cls->n_regs; ++j) {
+ for (j = 0; j < cls->n_regs; ++j) {
const arch_register_t *reg = arch_register_for_index(cls, j);
- if(arch_register_type_is(reg, caller_save)) {
+ if (arch_register_type_is(reg, caller_save)) {
pset_insert_ptr(caller_save, (void *) reg);
}
- if(arch_register_type_is(reg, state)) {
+ if (arch_register_type_is(reg, state)) {
pset_insert_ptr(caller_save, (void*) reg);
pset_insert_ptr(states, (void*) reg);
}
const ir_edge_t *res_edge;
ir_node *irn = get_edge_src_irn(edge);
- if(is_Proj(irn) && get_Proj_proj(irn) == pn_Call_T_result) {
+ if (is_Proj(irn) && get_Proj_proj(irn) == pn_Call_T_result) {
res_proj = irn;
foreach_out_edge(irn, res_edge) {
int proj;
assert(is_Proj(res));
proj = get_Proj_proj(res);
- arg = get_call_arg(call, 1, proj);
+ arg = get_call_arg(call, 1, proj);
/*
shift the proj number to the right, since we will drop the
set_Proj_proj(res, proj);
obstack_ptr_grow(obst, res);
- if(proj > curr_res_proj)
+ if (proj > curr_res_proj)
curr_res_proj = proj;
- if(arg->in_reg) {
+ if (arg->in_reg) {
pset_remove_ptr(caller_save, arg->reg);
//pmap_insert(arg_regs, arg->reg, INT_TO_PTR(proj + 1))
}
res_projs = obstack_finish(obst);
/* make the back end call node and set its register requirements. */
- for(i = 0; i < n_low_args; ++i) {
- obstack_ptr_grow(obst, get_Call_param(irn, low_args[i]));
+ for (i = 0; i < n_reg_params; ++i) {
+ obstack_ptr_grow(obst, get_Call_param(irn, reg_param_idxs[i]));
}
foreach_pset(states, reg) {
const arch_register_class_t *cls = arch_register_get_class(reg);
ir_node *regnode = new_rd_Unknown(irg, arch_register_class_mode(cls));
obstack_ptr_grow(obst, regnode);
}
- count = n_low_args + pset_count(states);
+ n_ins = n_reg_params + pset_count(states);
in = obstack_finish(obst);
- if(env->call->flags.bits.call_has_imm && get_irn_opcode(call_ptr) == iro_SymConst) {
+ if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
+ /* direct call */
low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem,
curr_sp, curr_sp,
- curr_res_proj + pset_count(caller_save), count,
+ curr_res_proj + pset_count(caller_save), n_ins,
in, get_Call_type(irn));
be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
} else {
+ /* indirect call */
low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem,
curr_sp, call_ptr,
curr_res_proj + pset_count(caller_save),
- count, in, get_Call_type(irn));
+ n_ins, in, get_Call_type(irn));
}
- ARR_APP1(ir_node*, env->calls, low_call);
+ ARR_APP1(ir_node *, env->calls, low_call);
/*
Set the register class of the call address to
DBG((env->dbg, LEVEL_3, "\tcreated backend call %+F\n", low_call));
/* Set the register classes and constraints of the Call parameters. */
- for(i = 0; i < n_low_args; ++i) {
- int index = low_args[i];
+ for (i = 0; i < n_reg_params; ++i) {
+ int index = reg_param_idxs[i];
be_abi_call_arg_t *arg = get_call_arg(call, 0, index);
assert(arg->reg != NULL);
set_Proj_pred(res_projs[i], low_call);
/* set the now unnecessary projT to bad */
- if(res_proj != NULL) {
+ if (res_proj != NULL) {
be_kill_node(res_proj);
}
}
/* Clean up the stack. */
- if(stack_size > 0) {
+ if (stack_size > 0) {
ir_node *mem_proj = NULL;
foreach_out_edge(low_call, edge) {
}
}
- if(!mem_proj) {
+ if (! mem_proj) {
mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_Call_M);
keep_alive(mem_proj);
}
/* Clean up the stack frame if we allocated it */
- if(!no_alloc) {
+ if (! no_alloc) {
curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size);
add_irn_dep(curr_sp, mem_proj);
- if(alloca_copy) {
+ if (alloca_copy) {
add_irn_dep(curr_sp, alloca_copy);
alloca_copy = NULL;
}
}
be_abi_call_free(call);
- obstack_free(obst, pos);
+ obstack_free(obst, stack_param_idx);
del_pset(results);
del_pset(states);
del_pset(caller_save);
typedef struct lower_frame_sels_env_t {
be_abi_irg_t *env;
ir_entity *value_param_list; /**< the list of all value param entities */
+ ir_entity *value_param_tail; /**< the tail of the list of all value param entities */
} lower_frame_sels_env_t;
/**
* Walker: Replaces Sels of frame type and
* value param type entities by FrameAddress.
+ * Links all used entities.
*/
-static void lower_frame_sels_walker(ir_node *irn, void *data)
-{
+static void lower_frame_sels_walker(ir_node *irn, void *data) {
lower_frame_sels_env_t *ctx = data;
if (is_Sel(irn)) {
nw = be_new_FrameAddr(env->isa->sp->reg_class, irg, bl, frame, ent);
exchange(irn, nw);
- /* check, if it's a param sel and if have not seen this entity immediatly before */
- if (ptr == param_base && ctx->value_param_list != ent) {
+ /* check, if it's a param sel and if have not seen this entity before */
+ if (ptr == param_base &&
+ ent != ctx->value_param_tail &&
+ get_entity_link(ent) == NULL) {
set_entity_link(ent, ctx->value_param_list);
ctx->value_param_list = ent;
+ if (ctx->value_param_tail == NULL) ctx->value_param_tail = ent;
}
}
}
ir_node *arg_tuple;
ir_node *value_param_base;
const ir_edge_t *edge;
- ir_type *arg_type, *bet_type;
+ ir_type *arg_type, *bet_type, *tp;
lower_frame_sels_env_t ctx;
ir_entity **param_map;
DBG((dbg, LEVEL_1, "introducing abi on %+F\n", irg));
+ /* set the links of all frame entities to NULL, we use it
+ to detect if an entity is already linked in the value_param_list */
+ tp = get_method_value_param_type(method_type);
+ if (tp != NULL) {
+ for (i = get_struct_n_members(tp) - 1; i >= 0; --i)
+ set_entity_link(get_struct_member(tp, i), NULL);
+ }
+
/* Convert the Sel nodes in the irg to frame load/store/addr nodes. */
ctx.env = env;
ctx.value_param_list = NULL;
+ ctx.value_param_tail = NULL;
irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
/* value_param_base anchor is not needed anymore now */
ir_node *irn;
sched_foreach(bl, irn) {
+ int ofs;
/*
Check, if the node relates to an entity on the stack frame.
DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n", ent, offset, bias));
}
- /*
- If the node modifies the stack pointer by a constant offset,
- record that in the bias.
- */
- if(arch_irn_is(arch_env, irn, modify_sp)) {
- int ofs = arch_get_sp_bias(arch_env, irn);
+ if(omit_fp || be_is_IncSP(irn)) {
+ /*
+ * If the node modifies the stack pointer by a constant offset,
+ * record that in the bias.
+ */
+ ofs = arch_get_sp_bias(arch_env, irn);
if(be_is_IncSP(irn)) {
if(ofs == BE_STACK_FRAME_SIZE_EXPAND) {