* moving the stack pointer along the stack's direction.
*/
if(stack_dir < 0 && !do_seq && !no_alloc) {
- curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, stack_size, be_stack_dir_along);
+ curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, stack_size, be_stack_dir_expand);
}
assert(mode_is_reference(mach_mode) && "machine mode must be pointer");
*/
if(do_seq) {
curr_ofs = 0;
- curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, param_size, be_stack_dir_along);
+ curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, param_size, be_stack_dir_expand);
curr_mem = mem;
}
}
unspeakable Proj_T from the Call. Therefore, all real argument
Proj numbers must be increased by pn_Call_max
*/
- proj += pn_Call_max;
+ proj += pn_Call_max;
set_Proj_proj(res, proj);
obstack_ptr_grow(obst, res);
be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
}
- else
+ else
low_call = be_new_Call(irg, bl, curr_mem, curr_sp, call_ptr, curr_res_proj + pset_count(caller_save), n_low_args, in);
+ set_irn_dbg_info(low_call, get_irn_dbg_info(irn));
+
/*
TODO:
Set the register class of the call address to the same as the stack pointer's.
/* Clean up the stack frame if we allocated it */
if(!no_alloc)
- curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, mem_proj, stack_size, be_stack_dir_against);
+ curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, mem_proj, stack_size, be_stack_dir_shrink);
}
be_abi_call_free(call);
*/
static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp)
{
- if(get_Alloc_where(alloc) == stack_alloc) {
+ if (get_Alloc_where(alloc) == stack_alloc) {
ir_node *bl = get_nodes_block(alloc);
ir_graph *irg = get_irn_irg(bl);
ir_node *alloc_mem = NULL;
}
}
+ /* TODO: Beware: currently Alloc nodes without a result might happen,
+ only escape analysis kills them and this phase runs only for object
+ oriented source. So this must be fixed. */
assert(alloc_res != NULL);
exchange(alloc_res, env->isa->stack_dir < 0 ? new_alloc : curr_sp);
int stack_nr = get_Proj_proj(stack);
if(flags.try_omit_fp) {
- stack = be_new_IncSP(sp, irg, bl, stack, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+ stack = be_new_IncSP(sp, irg, bl, stack, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_expand);
frame = stack;
}
arch_set_irn_register(env->birg->main_env->arch_env, frame, bp);
}
- stack = be_new_IncSP(sp, irg, bl, stack, frame, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+ stack = be_new_IncSP(sp, irg, bl, stack, frame, BE_STACK_FRAME_SIZE, be_stack_dir_expand);
}
be_node_set_flags(env->reg_params, -(stack_nr + 1), arch_irn_flags_ignore);
pmap_entry *ent;
if(env->call->flags.bits.try_omit_fp) {
- stack = be_new_IncSP(sp, irg, bl, stack, ret_mem, BE_STACK_FRAME_SIZE, be_stack_dir_against);
+ stack = be_new_IncSP(sp, irg, bl, stack, ret_mem, BE_STACK_FRAME_SIZE, be_stack_dir_shrink);
}
else {
static void create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *regs, int in_req)
{
ir_graph *irg = env->birg->irg;
- int i, n;
+ int n;
int n_regs = pmap_count(regs);
ir_node *irn;
ir_node **in;
rm = reg_map_to_arr(&env->obst, regs);
- for(i = 0, n = 0; i < n_regs; ++i, ++n)
- obstack_ptr_grow(&env->obst, rm[i].irn);
+ for(n = 0; n < n_regs; ++n)
+ obstack_ptr_grow(&env->obst, rm[n].irn);
if(mem) {
obstack_ptr_grow(&env->obst, *mem);
ir_node *proj;
const arch_register_t *reg = rm[n].reg;
- proj = new_r_Proj(env->birg->irg, bl, irn, get_irn_mode(rm[i].irn), n);
+ proj = new_r_Proj(env->birg->irg, bl, irn, get_irn_mode(rm[n].irn), n);
be_node_set_reg_class(irn, n, reg->reg_class);
if(in_req)
be_set_constr_single_reg(irn, n, reg);
create_barrier(env, bl, &mem, env->regs, 0);
env->init_sp = be_abi_reg_map_get(env->regs, sp);
- env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_along);
+ env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, no_mem, BE_STACK_FRAME_SIZE, be_stack_dir_expand);
arch_set_irn_register(env->birg->main_env->arch_env, env->init_sp, sp);
be_abi_reg_map_set(env->regs, sp, env->init_sp);
frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
}
/* The in array for the new back end return is now ready. */
- ret = be_new_Return(irg, bl, n, in);
+ ret = be_new_Return(get_irn_dbg_info(irn), irg, bl, n, in);
/* Set the register classes of the return's parameter accordingly. */
for(i = 0; i < n; ++i)
}
}
+ del_pset(dont_save);
obstack_free(&env->obst, args);
}
env->dce_survivor = new_survive_dce();
env->birg = birg;
- env->dbg = firm_dbg_register("firm.be.abi");
env->stack_phis = pset_new_ptr(16);
env->init_sp = dummy = new_r_Unknown(irg, env->isa->sp->reg_class->mode);
+ FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
env->cb = env->call->cb->init(env->call, birg->main_env->arch_env, irg);
}
/**
- * Translates a direction of an IncSP node (either be_stack_dir_against, or ...along)
+ * Translates a direction of an IncSP node (either be_stack_dir_shrink, or ...expand)
* into -1 or 1, respectively.
* @param irn The node.
* @return 1, if the direction of the IncSP was along, -1 if against.
*/
static int get_dir(ir_node *irn)
{
- return 1 - 2 * (be_get_IncSP_direction(irn) == be_stack_dir_against);
+ return 1 - 2 * (be_get_IncSP_direction(irn) == be_stack_dir_shrink);
}
static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
projects / libfirm / blobdiff