struct _be_abi_irg_t {
struct obstack obst;
- be_stack_layout_t *frame; /**< The stack frame model. */
be_irg_t *birg; /**< The back end IRG. */
- const arch_isa_t *isa; /**< The isa. */
+ const arch_env_t *arch_env;
survive_dce_t *dce_survivor;
be_abi_call_t *call; /**< The ABI call information. */
pmap *keep_map; /**< mapping blocks to keep nodes. */
pset *ignore_regs; /**< Additional registers which shall be ignored. */
- ir_node **calls; /**< flexible array containing all be_Call nodes */
+ ir_node **calls; /**< flexible array containing all be_Call nodes */
- arch_register_req_t sp_req;
- arch_register_req_t sp_cls_req;
+ arch_register_req_t sp_req;
+ arch_register_req_t sp_cls_req;
- DEBUG_ONLY(firm_dbg_module_t *dbg;) /**< The debugging module. */
+ be_stack_layout_t frame; /**< The stack frame model. */
+
+ DEBUG_ONLY(firm_dbg_module_t *dbg;) /**< The debugging module. */
};
static heights_t *ir_heights;
-/* Flag: if set, try to omit the frame pointer if called by the backend */
+/** Flag: if set, try to omit the frame pointer in all routines. */
static int be_omit_fp = 1;
-static int be_pic = 0;
+
+/** Flag: if set, try to omit the frame pointer in leaf routines only. */
+static int be_omit_leaf_fp = 1;
/*
_ ____ ___ ____ _ _ _ _
call->cb = NULL;
call->cls_addr = cls_addr;
- call->flags.bits.try_omit_fp = be_omit_fp;
+ call->flags.bits.try_omit_fp = be_omit_fp | be_omit_leaf_fp;
return call;
}
and the spills.
*/
-static int get_stack_entity_offset(be_stack_layout_t *frame, ir_entity *ent, int bias)
+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 i, index;
+ int index;
/* Find the type the entity is contained in. */
- for(index = 0; index < N_FRAME_TYPES; ++index) {
- if(frame->order[index] == t)
+ 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]);
}
- /* Add the size of all the types below the one of the entity to the entity's offset */
- for(i = 0; i < index; ++i)
- ofs += get_type_size_bytes(frame->order[i]);
-
/* correct the offset by the initial position of the frame pointer */
ofs -= frame->initial_offset;
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)
+ if (get_entity_offset(ent) == offset)
return ent;
}
frame->between_type = between;
frame->frame_type = locals;
frame->initial_offset = 0;
+ frame->initial_bias = 0;
frame->stack_dir = stack_dir;
frame->order[1] = between;
frame->param_map = param_map;
{
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 *call_tp = get_Call_type(irn);
ir_node *call_ptr = get_Call_ptr(irn);
int n_params = get_method_n_params(call_tp);
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);
+ int stack_dir = arch_env_stack_dir(arch_env);
+ const arch_register_t *sp = arch_env_sp(arch_env);
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;
int n_res = get_method_n_ress(call_tp);
+ int do_seq = call->flags.bits.store_args_sequential && !no_alloc;
ir_node *res_proj = NULL;
int n_reg_params = 0;
int i, n;
/* Let the isa fill out the abi description for that call node. */
- arch_isa_get_call_abi(isa, call_tp, call);
+ 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);
}
reg_param_idxs = obstack_finish(obst);
+ /*
+ * If the stack is decreasing and we do not want to store sequentially,
+ * or someone else allocated the call frame
+ * we allocate as much space on the stack all parameters need, by
+ * moving the stack pointer along the stack's direction.
+ *
+ * Note: we also have to do this for stack_size == 0, because we may have
+ * to adjust stack alignment for the call.
+ */
+ if (stack_dir < 0 && !do_seq && !no_alloc) {
+ curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size, 1);
+ }
+
/* If there are some parameters which shall be passed on the stack. */
if (n_stack_params > 0) {
int curr_ofs = 0;
- int do_seq = call->flags.bits.store_args_sequential && !no_alloc;
/*
* Reverse list of stack parameters if call arguments are from left to right.
}
}
- /*
- * If the stack is decreasing and we do not want to store sequentially,
- * or someone else allocated the call frame
- * 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) {
- curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, stack_size);
- }
-
curr_mem = get_Call_mem(irn);
if (! do_seq) {
obstack_ptr_grow(obst, curr_mem);
*/
if (do_seq) {
curr_ofs = 0;
- addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before);
+ addr = curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, param_size + arg->space_before, 0);
add_irn_dep(curr_sp, curr_mem);
}
else {
}
/* Collect caller save registers */
- for (i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
+ for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
unsigned j;
- const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
+ 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 (arch_register_type_is(reg, caller_save)) {
}
/** TODO: this is not correct for cases where return values are passed
- * on the stack, but no known ABI does this currentl...
+ * on the stack, but no known ABI does this currently...
*/
n_reg_results = n_res;
/* kill the ProjT node */
if (res_proj != NULL) {
- be_kill_node(res_proj);
+ kill_node(res_proj);
}
/* Make additional projs for the caller save registers
mem_proj = new_r_Proj(irg, bl, low_call, mode_M, pn_be_Call_M_regular);
keep_alive(mem_proj);
}
-
- /* Clean up the stack frame if we allocated it */
- if (! no_alloc) {
- curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size);
- }
+ }
+ /* Clean up the stack frame or revert alignment fixes if we allocated it */
+ if (! no_alloc) {
+ curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, -stack_size, 0);
}
be_abi_call_free(call);
ir_graph *irg, ir_node *block, dbg_info *dbg)
{
if (stack_alignment > 1) {
- ir_mode *mode = get_irn_mode(size);
- tarval *tv = new_tarval_from_long(stack_alignment-1, mode);
- ir_node *mask = new_r_Const(irg, block, mode, tv);
+ ir_mode *mode;
+ tarval *tv;
+ ir_node *mask;
+
+ assert(is_po2(stack_alignment));
+ mode = get_irn_mode(size);
+ tv = new_tarval_from_long(stack_alignment-1, mode);
+ mask = new_r_Const(irg, block, mode, tv);
size = new_rd_Add(dbg, irg, block, size, mask, mode);
tv = new_tarval_from_long(-(long)stack_alignment, mode);
ir_node *new_alloc, *size, *addr, *ins[2];
unsigned stack_alignment;
- if (get_Alloc_where(alloc) != stack_alloc) {
- assert(0);
- return alloc;
- }
+ assert(get_Alloc_where(alloc) == stack_alloc);
block = get_nodes_block(alloc);
irg = get_irn_irg(block);
ir_node *irn = get_edge_src_irn(edge);
assert(is_Proj(irn));
- switch(get_Proj_proj(irn)) {
+ switch (get_Proj_proj(irn)) {
case pn_Alloc_M:
alloc_mem = irn;
break;
dbg = get_irn_dbg_info(alloc);
/* we might need to multiply the size with the element size */
- if(type != get_unknown_type() && get_type_size_bytes(type) != 1) {
+ if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
tarval *tv = new_tarval_from_long(get_type_size_bytes(type),
mode_Iu);
ir_node *cnst = new_rd_Const(dbg, irg, block, mode_Iu, tv);
We cannot omit it. */
env->call->flags.bits.try_omit_fp = 0;
- /* FIXME: size must be here round up for the stack alignment, but
- this must be transmitted from the backend. */
- stack_alignment = 4;
+ stack_alignment = 1 << env->arch_env->stack_alignment;
size = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
- new_alloc = be_new_AddSP(env->isa->sp, irg, block, curr_sp, size);
+ new_alloc = be_new_AddSP(env->arch_env->sp, irg, block, curr_sp, size);
set_irn_dbg_info(new_alloc, dbg);
if(alloc_mem != NULL) {
unsigned stack_alignment;
dbg_info *dbg;
- if (get_Free_where(free) != stack_alloc) {
- assert(0);
- return free;
- }
+ 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->isa->sp->reg_class->mode;
+ 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 != get_unknown_type() && get_type_size_bytes(type) != 1) {
+ if (type != firm_unknown_type && get_type_size_bytes(type) != 1) {
tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu);
ir_node *cnst = new_rd_Const(dbg, irg, block, mode_Iu, tv);
ir_node *mul = new_rd_Mul(dbg, irg, block, get_Free_size(free),
size = get_Free_size(free);
}
- /* FIXME: size must be here round up for the stack alignment, but
- this must be transmitted from the backend. */
- stack_alignment = 4;
- size = adjust_alloc_size(stack_alignment, size, irg, block, dbg);
+ stack_alignment = 1 << env->arch_env->stack_alignment;
+ size = adjust_alloc_size(stack_alignment, size, irg, 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->isa->sp, irg, block, curr_sp, size);
+ subsp = be_new_SubSP(env->arch_env->sp, irg, block, curr_sp, size);
set_irn_dbg_info(subsp, dbg);
mem = new_r_Proj(irg, block, subsp, mode_M, pn_be_SubSP_M);
}
/**
- * Walker: links all Call/alloc/Free nodes to the Block they are contained.
+ * Walker: links all Call/Alloc/Free nodes to the Block they are contained.
+ * Clears the irg_is_leaf flag if a Call is detected.
*/
-static void link_calls_in_block_walker(ir_node *irn, void *data)
+static void link_ops_in_block_walker(ir_node *irn, void *data)
{
ir_opcode code = get_irn_opcode(irn);
if (code == iro_Call ||
- (code == iro_Alloc && get_Alloc_where(irn) == stack_alloc) ||
- (code == iro_Free && get_Free_where(irn) == stack_alloc)) {
+ (code == iro_Alloc && get_Alloc_where(irn) == stack_alloc) ||
+ (code == iro_Free && get_Free_where(irn) == stack_alloc)) {
be_abi_irg_t *env = data;
ir_node *bl = get_nodes_block(irn);
void *save = get_irn_link(bl);
/**
* Block-walker:
- * Process all Call nodes inside a basic block.
+ * Process all Call/Alloc/Free nodes inside a basic block.
* Note that the link field of the block must contain a linked list of all
* Call nodes inside the Block. We first order this list according to data dependency
* and that connect the calls together.
*/
-static void process_calls_in_block(ir_node *bl, void *data)
+static void process_ops_in_block(ir_node *bl, void *data)
{
be_abi_irg_t *env = data;
ir_node *curr_sp = env->init_sp;
ir_node *irn;
int n;
- for(irn = get_irn_link(bl), n = 0; irn; irn = get_irn_link(irn), ++n)
+ for (irn = get_irn_link(bl), n = 0; irn; irn = get_irn_link(irn), ++n)
obstack_ptr_grow(&env->obst, irn);
/* If there were call nodes in the block. */
- if(n > 0) {
+ if (n > 0) {
ir_node *keep;
ir_node **nodes;
int i;
/* order the call nodes according to data dependency */
qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependency);
- for(i = n - 1; i >= 0; --i) {
+ for (i = n - 1; i >= 0; --i) {
ir_node *irn = nodes[i];
DBG((env->dbg, LEVEL_3, "\tprocessing call %+F\n", irn));
- switch(get_irn_opcode(irn)) {
+ switch (get_irn_opcode(irn)) {
case iro_Call:
+ if (! be_omit_fp) {
+ /* The stack pointer will be modified due to a call. */
+ env->call->flags.bits.try_omit_fp = 0;
+ }
curr_sp = adjust_call(env, irn, curr_sp);
break;
case iro_Alloc:
- curr_sp = adjust_alloc(env, irn, curr_sp);
+ if (get_Alloc_where(irn) == stack_alloc)
+ curr_sp = adjust_alloc(env, irn, curr_sp);
break;
case iro_Free:
- curr_sp = adjust_free(env, irn, curr_sp);
+ if (get_Free_where(irn) == stack_alloc)
+ curr_sp = adjust_free(env, irn, curr_sp);
break;
default:
panic("invalid call");
/* Keep the last stack state in the block by tying it to Keep node,
* the proj from calls is already kept */
- if(curr_sp != env->init_sp
- && !(is_Proj(curr_sp) && be_is_Call(get_Proj_pred(curr_sp)))) {
+ if (curr_sp != env->init_sp &&
+ !(is_Proj(curr_sp) && be_is_Call(get_Proj_pred(curr_sp)))) {
nodes[0] = curr_sp;
- keep = be_new_Keep(env->isa->sp->reg_class, get_irn_irg(bl),
- bl, 1, nodes);
+ keep = be_new_Keep(env->arch_env->sp->reg_class,
+ get_irn_irg(bl), bl, 1, nodes);
pmap_insert(env->keep_map, bl, keep);
}
}
ir_graph *irg = env->birg->irg;
env->call->flags.bits.irg_is_leaf = 1;
- irg_walk_graph(irg, firm_clear_link, link_calls_in_block_walker, env);
+ irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, env);
ir_heights = heights_new(env->birg->irg);
- irg_block_walk_graph(irg, NULL, process_calls_in_block, env);
+ irg_block_walk_graph(irg, NULL, process_ops_in_block, env);
heights_free(ir_heights);
}
static ir_type *compute_arg_type(be_abi_irg_t *env, 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 = env->birg->main_env->arch_env->isa->stack_dir * dir;
+ int inc = env->birg->main_env->arch_env->stack_dir * dir;
int n = get_method_n_params(method_type);
int curr = inc > 0 ? 0 : n - 1;
int ofs = 0;
obstack_init(&obst);
/* Create a Perm after the RegParams node to delimit it. */
- for(i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
+ for (i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
ir_node *perm;
ir_node **in;
int n_regs;
- for(n_regs = 0, j = 0; j < cls->n_regs; ++j) {
+ for (n_regs = 0, j = 0; j < cls->n_regs; ++j) {
const arch_register_t *reg = &cls->regs[j];
ir_node *irn = pmap_get(regs, (void *) reg);
obstack_ptr_grow(&obst, NULL);
in = obstack_finish(&obst);
- if(n_regs > 0) {
+ if (n_regs > 0) {
perm = be_new_Perm(cls, irg, bl, n_regs, in);
- for(j = 0; j < n_regs; ++j) {
+ for (j = 0; j < n_regs; ++j) {
ir_node *arg = in[j];
arch_register_t *reg = get_irn_link(arg);
pmap_insert(regs, reg, arg);
rm = reg_map_to_arr(&env->obst, regs);
- for(n = 0; n < n_regs; ++n)
+ for (n = 0; n < n_regs; ++n)
obstack_ptr_grow(&env->obst, rm[n].irn);
- if(mem) {
+ if (mem) {
obstack_ptr_grow(&env->obst, *mem);
n++;
}
proj = new_r_Proj(irg, bl, irn, get_irn_mode(rm[n].irn), n);
be_node_set_reg_class(irn, n, reg->reg_class);
- if(in_req)
+ if (in_req)
be_set_constr_single_reg(irn, n, reg);
be_set_constr_single_reg(irn, pos, reg);
be_node_set_reg_class(irn, pos, reg->reg_class);
arch_set_irn_register(env->birg->main_env->arch_env, proj, reg);
/* if the proj projects a ignore register or a node which is set to ignore, propagate this property. */
- if(arch_register_type_is(reg, ignore) || arch_irn_is(env->birg->main_env->arch_env, in[n], ignore))
+ if (arch_register_type_is(reg, ignore) || arch_irn_is(env->birg->main_env->arch_env, in[n], ignore))
flags |= arch_irn_flags_ignore;
- if(arch_irn_is(env->birg->main_env->arch_env, in[n], modify_sp))
+ if (arch_irn_is(env->birg->main_env->arch_env, in[n], modify_sp))
flags |= arch_irn_flags_modify_sp;
be_node_set_flags(irn, pos, flags);
pmap_insert(regs, (void *) reg, proj);
}
- if(mem) {
+ if (mem) {
*mem = new_r_Proj(irg, bl, irn, mode_M, n);
}
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_isa_t *isa = env->birg->main_env->arch_env->isa;
+ be_abi_call_t *call = env->call;
+ const arch_env_t *arch_env = env->birg->main_env->arch_env;
dbg_info *dbgi;
pmap *reg_map = pmap_create();
ir_node *keep = pmap_get(env->keep_map, bl);
it then. Else we use the stack from the start block and let
the ssa construction fix the usage.
*/
- stack = be_abi_reg_map_get(env->regs, isa->sp);
+ stack = be_abi_reg_map_get(env->regs, arch_env->sp);
if (keep) {
stack = get_irn_n(keep, 0);
- be_kill_node(keep);
+ kill_node(keep);
remove_End_keepalive(get_irg_end(env->birg->irg), keep);
}
/* Insert results for Return into the register map. */
- for(i = 0; i < n_res; ++i) {
+ for (i = 0; i < n_res; ++i) {
ir_node *res = get_Return_res(irn, i);
be_abi_call_arg_t *arg = get_call_arg(call, 1, i);
assert(arg->in_reg && "return value must be passed in register");
pmap_insert(reg_map, ent->key, ent->value);
}
- be_abi_reg_map_set(reg_map, isa->sp, stack);
+ be_abi_reg_map_set(reg_map, arch_env->sp, stack);
/* Make the Epilogue node and call the arch's epilogue maker. */
create_barrier(env, bl, &mem, reg_map, 1);
regs = obstack_alloc(&env->obst, in_max * sizeof(regs[0]));
in[0] = mem;
- in[1] = be_abi_reg_map_get(reg_map, isa->sp);
+ in[1] = be_abi_reg_map_get(reg_map, arch_env->sp);
regs[0] = NULL;
- regs[1] = isa->sp;
+ regs[1] = arch_env->sp;
n = 2;
/* clear SP entry, since it has already been grown. */
- pmap_insert(reg_map, (void *) isa->sp, NULL);
- for(i = 0; i < n_res; ++i) {
+ 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);
in[n] = be_abi_reg_map_get(reg_map, arg->reg);
/* grow the rest of the stuff. */
foreach_pmap(reg_map, ent) {
- if(ent->value) {
+ if (ent->value) {
in[n] = ent->value;
regs[n++] = ent->key;
}
}
/* The in array for the new back end return is now ready. */
- if(irn != NULL) {
+ if (irn != NULL) {
dbgi = get_irn_dbg_info(irn);
} else {
dbgi = NULL;
ret = be_new_Return(dbgi, env->birg->irg, bl, n_res, pop, n, in);
/* Set the register classes of the return's parameter accordingly. */
- for(i = 0; i < n; ++i)
- if(regs[i])
+ for (i = 0; i < n; ++i)
+ if (regs[i])
be_node_set_reg_class(ret, i, regs[i]->reg_class);
/* Free the space of the Epilog's in array and the register <-> proj map. */
ir_node *bl = get_nodes_block(irn);
ir_node *nw;
- nw = be_new_FrameAddr(env->isa->sp->reg_class, irg, bl, frame, ent);
+ nw = be_new_FrameAddr(env->arch_env->sp->reg_class, irg, bl, frame, ent);
exchange(irn, nw);
/* check, if it's a param sel and if have not seen this entity before */
ir_node *addr;
/* address for the backing store */
- addr = be_new_FrameAddr(env->isa->sp->reg_class, irg, first_bl, frame, ent);
+ addr = be_new_FrameAddr(env->arch_env->sp->reg_class, irg, first_bl, frame, ent);
if (store)
mem = new_r_Proj(irg, first_bl, store, mode_M, pn_Store_M);
static void modify_irg(be_abi_irg_t *env)
{
be_abi_call_t *call = env->call;
- const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
- const arch_register_t *sp = arch_isa_sp(isa);
+ const arch_env_t *arch_env= env->birg->main_env->arch_env;
+ const arch_register_t *sp = arch_env_sp(arch_env);
ir_graph *irg = env->birg->irg;
- ir_node *bl = get_irg_start_block(irg);
- ir_node *end = get_irg_end_block(irg);
- ir_node *old_mem = get_irg_initial_mem(irg);
+ ir_node *start_bl;
+ 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));
- pset *dont_save = pset_new_ptr(8);
int n_params;
int i, n;
/* value_param_base anchor is not needed anymore now */
value_param_base = get_irg_value_param_base(irg);
- be_kill_node(value_param_base);
+ kill_node(value_param_base);
set_irg_value_param_base(irg, new_r_Bad(irg));
- env->frame = obstack_alloc(&env->obst, sizeof(env->frame[0]));
env->regs = pmap_create();
used_proj_nr = bitset_alloca(1024);
arg_type = compute_arg_type(env, call, method_type, ¶m_map);
bet_type = call->cb->get_between_type(env->cb);
- stack_frame_init(env->frame, arg_type, bet_type, get_irg_frame_type(irg), isa->stack_dir, param_map);
+ stack_frame_init(&env->frame, arg_type, bet_type, get_irg_frame_type(irg), arch_env->stack_dir, param_map);
/* Count the register params and add them to the number of Projs for the RegParams node */
- 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);
- if(arg->in_reg && args[i]) {
+ if (arg->in_reg && args[i]) {
assert(arg->reg != sp && "cannot use stack pointer as parameter register");
assert(i == get_Proj_proj(args[i]));
}
/* Collect all callee-save registers */
- for(i = 0, n = arch_isa_get_n_reg_class(isa); i < n; ++i) {
- const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
- for(j = 0; j < cls->n_regs; ++j) {
+ for (i = 0, n = arch_env_get_n_reg_class(arch_env); i < n; ++i) {
+ 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 = &cls->regs[j];
- if(arch_register_type_is(reg, callee_save) ||
+ if (arch_register_type_is(reg, callee_save) ||
arch_register_type_is(reg, state)) {
pmap_insert(env->regs, (void *) reg, NULL);
}
}
pmap_insert(env->regs, (void *) sp, NULL);
- pmap_insert(env->regs, (void *) isa->bp, NULL);
+ pmap_insert(env->regs, (void *) arch_env->bp, NULL);
reg_params_bl = get_irg_start_block(irg);
env->reg_params = be_new_RegParams(irg, reg_params_bl, pmap_count(env->regs));
add_irn_dep(env->reg_params, get_irg_start(irg));
*/
rm = reg_map_to_arr(&env->obst, env->regs);
- for(i = 0, n = pmap_count(env->regs); i < n; ++i) {
+ for (i = 0, n = pmap_count(env->regs); i < n; ++i) {
arch_register_t *reg = (void *) rm[i].reg;
ir_mode *mode = reg->reg_class->mode;
long nr = i;
* If the register is an ignore register,
* The Proj for that register shall also be ignored during register allocation.
*/
- if(arch_register_type_is(reg, ignore))
+ if (arch_register_type_is(reg, ignore))
flags |= arch_irn_flags_ignore;
- if(reg == sp)
+ if (reg == sp)
flags |= arch_irn_flags_modify_sp;
be_node_set_flags(env->reg_params, pos, flags);
obstack_free(&env->obst, rm);
/* create a new initial memory proj */
+ old_mem = get_irg_initial_mem(irg);
assert(is_Proj(old_mem));
new_mem_proj = new_r_Proj(irg, get_nodes_block(old_mem),
new_r_Unknown(irg, mode_T), mode_M,
mem = new_mem_proj;
/* Generate the Prologue */
- fp_reg = call->cb->prologue(env->cb, &mem, env->regs);
+ fp_reg = call->cb->prologue(env->cb, &mem, env->regs, &env->frame.initial_bias);
/* do the stack allocation BEFORE the barrier, or spill code
might be added before it */
env->init_sp = be_abi_reg_map_get(env->regs, sp);
- env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND);
+ start_bl = get_irg_start_block(irg);
+ env->init_sp = be_new_IncSP(sp, irg, start_bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND, 0);
be_abi_reg_map_set(env->regs, sp, env->init_sp);
- create_barrier(env, bl, &mem, env->regs, 0);
+ create_barrier(env, start_bl, &mem, env->regs, 0);
env->init_sp = be_abi_reg_map_get(env->regs, sp);
arch_set_irn_register(env->birg->main_env->arch_env, env->init_sp, sp);
set_irg_initial_mem(irg, mem);
/* Now, introduce stack param nodes for all parameters passed on the stack */
- for(i = 0; i < n_params; ++i) {
+ for (i = 0; i < n_params; ++i) {
ir_node *arg_proj = args[i];
ir_node *repl = NULL;
- if(arg_proj != NULL) {
+ if (arg_proj != NULL) {
be_abi_call_arg_t *arg;
ir_type *param_type;
int nr = get_Proj_proj(arg_proj);
if (arg->in_reg) {
repl = pmap_get(env->regs, (void *) arg->reg);
- } else if(arg->on_stack) {
+ } else if (arg->on_stack) {
ir_node *addr = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent);
/* For atomic parameters which are actually used, we create a Load node. */
/* the arg proj is not needed anymore now and should be only used by the anchor */
assert(get_irn_n_edges(arg_tuple) == 1);
- be_kill_node(arg_tuple);
+ kill_node(arg_tuple);
set_irg_args(irg, new_rd_Bad(irg));
/* All Return nodes hang on the End node, so look for them there. */
+ end = get_irg_end_block(irg);
for (i = 0, n = get_Block_n_cfgpreds(end); i < n; ++i) {
ir_node *irn = get_Block_cfgpred(end, i);
/* if we have endless loops here, n might be <= 0. Do NOT create a be_Return then,
the code is dead and will never be executed. */
- del_pset(dont_save);
obstack_free(&env->obst, args);
/* handle start block here (place a jump in the block) */
static
void fix_call_state_inputs(be_abi_irg_t *env)
{
- const arch_isa_t *isa = env->isa;
+ const arch_env_t *arch_env = env->arch_env;
int i, n, n_states;
arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0);
/* Collect caller save registers */
- n = arch_isa_get_n_reg_class(isa);
- for(i = 0; i < n; ++i) {
+ n = arch_env_get_n_reg_class(arch_env);
+ for (i = 0; i < n; ++i) {
unsigned j;
- const arch_register_class_t *cls = arch_isa_get_reg_class(isa, i);
- for(j = 0; j < cls->n_regs; ++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(arch_register_type_is(reg, state)) {
+ if (arch_register_type_is(reg, state)) {
ARR_APP1(arch_register_t*, stateregs, (arch_register_t *)reg);
}
}
n = ARR_LEN(env->calls);
n_states = ARR_LEN(stateregs);
- for(i = 0; i < n; ++i) {
+ for (i = 0; i < n; ++i) {
int s, arity;
ir_node *call = env->calls[i];
arity = get_irn_arity(call);
- /* the statereg inputs are the last n inputs of the calls */
- for(s = 0; s < n_states; ++s) {
+ /* the state reg inputs are the last n inputs of the calls */
+ for (s = 0; s < n_states; ++s) {
int inp = arity - n_states + s;
const arch_register_t *reg = stateregs[s];
ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
set_irn_n(call, inp, regnode);
}
}
+
+ DEL_ARR_F(stateregs);
}
+/**
+ * Create a trampoline entity for the given method.
+ */
static ir_entity *create_trampoline(be_main_env_t *be, ir_entity *method)
{
ir_type *type = get_entity_type(method);
return ent;
}
+/**
+ * Returns the trampoline entity for the given method.
+ */
+static ir_entity *get_trampoline(be_main_env_t *env, ir_entity *method)
+{
+ ir_entity *result = pmap_get(env->ent_trampoline_map, method);
+ if (result == NULL) {
+ result = create_trampoline(env, method);
+ pmap_insert(env->ent_trampoline_map, method, result);
+ }
+
+ return result;
+}
+
+static ir_entity *create_pic_symbol(be_main_env_t *be, ir_entity *entity)
+{
+ ident *old_id = get_entity_ld_ident(entity);
+ ident *id = mangle3("L", old_id, "$non_lazy_ptr");
+ ir_type *e_type = get_entity_type(entity);
+ ir_type *type = new_type_pointer(id, e_type, mode_P_data);
+ ir_type *parent = be->pic_symbols_type;
+ ir_entity *ent = new_entity(parent, old_id, type);
+ set_entity_ld_ident(ent, id);
+ set_entity_visibility(ent, visibility_local);
+ set_entity_variability(ent, variability_uninitialized);
+
+ return ent;
+}
+
+static ir_entity *get_pic_symbol(be_main_env_t *env, ir_entity *entity)
+{
+ ir_entity *result = pmap_get(env->ent_pic_symbol_map, entity);
+ if (result == NULL) {
+ result = create_pic_symbol(env, entity);
+ pmap_insert(env->ent_pic_symbol_map, entity, result);
+ }
+
+ return result;
+}
+
+
+
+/**
+ * Returns non-zero if a given entity can be accessed using a relative address.
+ */
static int can_address_relative(ir_entity *entity)
{
return get_entity_variability(entity) == variability_initialized
arity = get_irn_arity(node);
for (i = 0; i < arity; ++i) {
+ dbg_info *dbgi;
ir_node *pred = get_irn_n(node, i);
ir_entity *entity;
+ ir_entity *pic_symbol;
+ ir_node *pic_symconst;
+
if (!is_SymConst(pred))
continue;
/* calls can jump to relative addresses, so we can directly jump to
the (relatively) known call address or the trampoline */
if (is_Call(node) && i == 1) {
- dbg_info *dbgi;
ir_entity *trampoline;
ir_node *trampoline_const;
continue;
dbgi = get_irn_dbg_info(pred);
- trampoline = create_trampoline(be, entity);
- trampoline_const = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code, trampoline, NULL);
+ trampoline = get_trampoline(be, entity);
+ trampoline_const = new_rd_SymConst_addr_ent(dbgi, irg, mode_P_code,
+ trampoline, NULL);
set_irn_n(node, i, trampoline_const);
continue;
}
continue;
}
+ /* get entry from pic symbol segment */
+ 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);
+ set_Add_right(add, pic_symconst);
+
/* 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 */
optimization_state_t state;
unsigned *limited_bitset;
- be_omit_fp = birg->main_env->options->omit_fp;
- be_pic = birg->main_env->options->pic;
+ be_omit_fp = birg->main_env->options->omit_fp;
+ be_omit_leaf_fp = birg->main_env->options->omit_leaf_fp;
obstack_init(&env->obst);
- env->isa = birg->main_env->arch_env->isa;
+ 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->isa->sp->reg_class);
- arch_isa_get_call_abi(env->isa, env->method_type, env->call);
+ 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->birg = birg;
env->sp_req.type = arch_register_req_type_limited;
- env->sp_req.cls = arch_register_get_class(env->isa->sp);
+ env->sp_req.cls = arch_register_get_class(env->arch_env->sp);
limited_bitset = rbitset_obstack_alloc(&env->obst, env->sp_req.cls->n_regs);
- rbitset_set(limited_bitset, arch_register_get_index(env->isa->sp));
+ rbitset_set(limited_bitset, arch_register_get_index(env->arch_env->sp));
env->sp_req.limited = limited_bitset;
env->sp_cls_req.type = arch_register_req_type_normal;
- env->sp_cls_req.cls = arch_register_get_class(env->isa->sp);
+ env->sp_cls_req.cls = arch_register_get_class(env->arch_env->sp);
/* Beware: later we replace this node by the real one, ensure it is not CSE'd
to another Unknown or the stack pointer gets used */
save_optimization_state(&state);
set_optimize(0);
- env->init_sp = dummy = new_r_Unknown(irg, env->isa->sp->reg_class->mode);
+ env->init_sp = dummy = new_r_Unknown(irg, env->arch_env->sp->reg_class->mode);
restore_optimization_state(&state);
FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
env->calls = NEW_ARR_F(ir_node*, 0);
- if (be_pic) {
+ if (birg->main_env->options->pic) {
irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
}
bitset_set(bs, reg->index);
}
+void be_abi_set_non_ignore_regs(be_abi_irg_t *abi, const arch_register_class_t *cls, unsigned *raw_bitset)
+{
+ unsigned i;
+ arch_register_t *reg;
+
+ for (i = 0; i < cls->n_regs; ++i) {
+ if (arch_register_type_is(&cls->regs[i], ignore))
+ continue;
+
+ rbitset_set(raw_bitset, i);
+ }
+
+ for (reg = pset_first(abi->ignore_regs); reg != NULL;
+ reg = pset_next(abi->ignore_regs)) {
+ if (reg->reg_class != cls)
+ continue;
+
+ rbitset_clear(raw_bitset, reg->index);
+ }
+}
+
/* 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;
+ return &abi->frame;
}
/*
be_irg_t *birg = env->birg;
be_lv_t *lv = be_get_birg_liveness(birg);
fix_stack_walker_env_t walker_env;
- arch_isa_t *isa;
walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0);
walker_env.arch_env = birg->main_env->arch_env;
- isa = walker_env.arch_env->isa;
irg_walk_graph(birg->irg, collect_stack_nodes_walker, NULL, &walker_env);
* now.
*/
len = ARR_LEN(walker_env.sp_nodes);
- if(len == 0) {
+ if (len == 0) {
DEL_ARR_F(walker_env.sp_nodes);
return;
}
ir_node *phi = phis[i];
be_set_phi_reg_req(walker_env.arch_env, phi, &env->sp_req);
be_set_phi_flags(walker_env.arch_env, phi, arch_irn_flags_ignore | arch_irn_flags_modify_sp);
- arch_set_irn_register(walker_env.arch_env, phi, env->isa->sp);
+ arch_set_irn_register(walker_env.arch_env, phi, env->arch_env->sp);
}
be_ssa_construction_destroy(&senv);
DEL_ARR_F(walker_env.sp_nodes);
}
-static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
+/**
+ * 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)
{
const arch_env_t *arch_env = env->birg->main_env->arch_env;
- int omit_fp = env->call->flags.bits.try_omit_fp;
- ir_node *irn;
+ int omit_fp = env->call->flags.bits.try_omit_fp;
+ ir_node *irn;
+ int wanted_bias = real_bias;
sched_foreach(bl, irn) {
int ofs;
node.
*/
ir_entity *ent = arch_get_frame_entity(arch_env, irn);
- if(ent) {
- int offset = get_stack_entity_offset(env->frame, ent, bias);
+ if (ent) {
+ int bias = omit_fp ? real_bias : 0;
+ int offset = get_stack_entity_offset(&env->frame, ent, bias);
arch_set_frame_offset(arch_env, irn, offset);
- DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n", ent, offset, bias));
+ DBG((env->dbg, LEVEL_2, "%F has offset %d (including bias %d)\n",
+ ent, offset, bias));
}
- 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) {
- ofs = (int)get_type_size_bytes(get_irg_frame_type(env->birg->irg));
- be_set_IncSP_offset(irn, ofs);
- } else if(ofs == BE_STACK_FRAME_SIZE_SHRINK) {
- ofs = - (int)get_type_size_bytes(get_irg_frame_type(env->birg->irg));
- be_set_IncSP_offset(irn, ofs);
+ /*
+ * 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)) {
+ /* 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;
+ }
}
}
-
- if(omit_fp)
- bias += ofs;
}
+
+ real_bias += ofs;
+ wanted_bias += ofs;
}
- return bias;
+ assert(real_bias == wanted_bias);
+ return real_bias;
}
/**
*/
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. */
- ir_node *start_block; /**< The start block of the current graph. */
+ 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
+ * Block-Walker: fix all stack offsets for all blocks
+ * except the start block
*/
static void stack_bias_walker(ir_node *bl, void *data)
{
void be_abi_fix_stack_bias(be_abi_irg_t *env)
{
- ir_graph *irg = env->birg->irg;
- struct bias_walk bw;
+ ir_graph *irg = env->birg->irg;
+ struct bias_walk bw;
- stack_frame_compute_initial_offset(env->frame);
- // stack_layout_dump(stdout, env->frame);
+ 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), 0);
+ 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;
projects / libfirm / blobdiff