static const arch_irn_ops_if_t abi_irn_ops;
static const arch_irn_handler_t abi_irn_handler;
+/* Flag: if set, try to omit the frame pointer if called by the backend */
+int be_omit_fp = 1;
+
/*
_ ____ ___ ____ _ _ _ _
/ \ | __ )_ _| / ___|__ _| | | |__ __ _ ___| | _____
*
* @return the new ABI call object
*/
-static be_abi_call_t *be_abi_call_new(void)
+static be_abi_call_t *be_abi_call_new()
{
be_abi_call_t *call = xmalloc(sizeof(call[0]));
call->flags.val = 0;
call->params = new_set(cmp_call_arg, 16);
call->cb = NULL;
+
+ call->flags.bits.try_omit_fp = be_omit_fp;
return call;
}
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(call->flags.bits.left_to_right) {
- for(i = 0; i < n_pos / 2; ++i) {
+ /*
+ * Reverse list of stack parameters if call arguments are from left to right.
+ * We must them reverse again in they are pushed (not stored) and the stack
+ * 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];
*/
if(do_seq) {
curr_ofs = 0;
- curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, no_mem, param_size, be_stack_dir_expand);
+ curr_sp = be_new_IncSP(sp, irg, bl, curr_sp, curr_mem, param_size, be_stack_dir_expand);
curr_mem = mem;
}
}
const ir_edge_t *edge;
ir_node *new_alloc;
- env->call->flags.bits.try_omit_fp = 0;
-
- new_alloc = be_new_AddSP(env->isa->sp, irg, bl, curr_sp, get_Alloc_size(alloc));
-
foreach_out_edge(alloc, edge) {
ir_node *irn = get_edge_src_irn(edge);
}
}
- /* 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);
+ /* Beware: currently Alloc nodes without a result might happen,
+ only escape analysis kills them and this phase runs only for object
+ oriented source. We kill the Alloc here. */
+ if (alloc_res == NULL) {
+ exchange(alloc_mem, get_Alloc_mem(alloc));
+ return curr_sp;
+ }
+
+ /* The stack pointer will be modified in an unknown manner.
+ We cannot omit it. */
+ env->call->flags.bits.try_omit_fp = 0;
+ new_alloc = be_new_AddSP(env->isa->sp, irg, bl, curr_sp, get_Alloc_size(alloc));
+
exchange(alloc_res, env->isa->stack_dir < 0 ? new_alloc : curr_sp);
if(alloc_mem != NULL)
}
}
+#if 0 /*
static ir_node *setup_frame(be_abi_irg_t *env)
{
const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
obstack_ptr_grow(obst, irn);
}
}
+*/
+#endif
static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type)
{
return res;
}
-static void create_barrier(be_abi_irg_t *env, ir_node *bl, ir_node **mem, pmap *regs, int in_req)
+static ir_node *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 n;
}
obstack_free(&env->obst, rm);
+ return irn;
}
/**
pset *dont_save = pset_new_ptr(8);
int n_params = get_method_n_params(method_type);
int max_arg = 0;
- DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
int i, j, n;
reg_node_map_t *rm;
const arch_register_t *fp_reg;
ir_node *frame_pointer;
+ ir_node *barrier;
ir_node *reg_params_bl;
ir_node **args;
const ir_edge_t *edge;
pmap_entry *ent;
bitset_t *used_proj_nr;
+ DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
DBG((dbg, LEVEL_1, "introducing abi on %+F\n", irg));
obstack_free(&env->obst, rm);
/* Generate the Prologue */
- fp_reg = call->cb->prologue(env->cb, &mem, env->regs);
- create_barrier(env, bl, &mem, env->regs, 0);
+ fp_reg = call->cb->prologue(env->cb, &mem, env->regs);
+ barrier = 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_expand);
frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
set_irg_frame(irg, frame_pointer);
+ if (is_Proj(frame_pointer) && get_Proj_pred(frame_pointer) == barrier)
+ be_node_set_flags(barrier, BE_OUT_POS(get_Proj_proj(frame_pointer)), arch_irn_flags_ignore);
+
/* Now, introduce stack param nodes for all parameters passed on the stack */
for(i = 0; i < max_arg; ++i) {
ir_node *arg_proj = args[i];
*/
+/**
+ * Walker. Collect all stack modifying nodes.
+ */
static void collect_stack_nodes_walker(ir_node *irn, void *data)
{
pset *s = data;
int start_block_bias; /**< The bias at the end of the start block. */
};
+/**
+ * Block-Walker: fix all stack offsets
+ */
static void stack_bias_walker(ir_node *bl, void *data)
{
if(bl != get_irg_start_block(get_irn_irg(bl))) {
stack_frame_compute_initial_offset(env->frame);
// stack_frame_dump(stdout, env->frame);
- /* Determine the stack bias at the and of the start block. */
+ /* 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);
/* fix the bias is all other blocks */
projects / libfirm / blobdiff