#include "be.h"
#include "beabi.h"
+#include "beabihelper.h"
#include "bearch.h"
#include "benode.h"
#include "belive_t.h"
} be_abi_call_arg_t;
struct be_abi_call_t {
- be_abi_call_flags_t flags; /**< Flags describing the ABI behavior on calls */
- int pop; /**< number of bytes the stack frame is shrinked by the callee on return. */
- const be_abi_callbacks_t *cb;
- ir_type *between_type;
- set *params;
- const arch_register_class_t *cls_addr; /**< register class of the call address */
+ be_abi_call_flags_t flags; /**< Flags describing the ABI behavior on calls */
+ int pop; /**< number of bytes the stack frame is shrinked by the callee on return. */
+ const be_abi_callbacks_t *cb;
+ set *params;
};
/**
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 pmap_get(ir_node, map, reg);
call->pop = pop;
}
-/* Set register class for call address */
-void be_abi_call_set_call_address_reg_class(be_abi_call_t *call, const arch_register_class_t *cls)
-{
- call->cls_addr = cls;
-}
-
-
void be_abi_call_param_stack(be_abi_call_t *call, int arg_pos,
ir_mode *load_mode, unsigned alignment,
unsigned space_before, unsigned space_after,
/**
* Constructor for a new ABI call object.
*
- * @param cls_addr register class of the call address
- *
* @return the new ABI call object
*/
-static be_abi_call_t *be_abi_call_new(const arch_register_class_t *cls_addr)
+static be_abi_call_t *be_abi_call_new(void)
{
be_abi_call_t *call = XMALLOCZ(be_abi_call_t);
- call->flags.val = 0;
- call->params = new_set(cmp_call_arg, 16);
- call->cb = NULL;
- call->cls_addr = cls_addr;
-
- call->flags.bits.try_omit_fp = be_omit_fp;
+ call->params = new_set(cmp_call_arg, 16);
+ call->cb = NULL;
+ call->flags.try_omit_fp = be_options.omit_fp;
return call;
}
ir_node *bl = get_nodes_block(irn);
int stack_size = 0;
const arch_register_t *sp = arch_env->sp;
- be_abi_call_t *call = be_abi_call_new(sp->reg_class);
+ be_abi_call_t *call = be_abi_call_new();
ir_mode *mach_mode = sp->reg_class->mode;
int n_res = get_method_n_ress(call_tp);
/* ins collected, build the call */
throws_exception = ir_throws_exception(irn);
- if (env->call->flags.bits.call_has_imm && is_SymConst(call_ptr)) {
+ if (env->call->flags.call_has_imm && is_SymConst(call_ptr)) {
/* direct call */
low_call = be_new_Call(dbgi, irg, bl, curr_mem, sp->single_req, curr_sp,
sp->single_req, curr_sp,
} else {
/* indirect call */
low_call = be_new_Call(dbgi, irg, bl, curr_mem, sp->single_req, curr_sp,
- call->cls_addr->class_req, call_ptr,
+ sp->reg_class->class_req, call_ptr,
n_reg_results + pn_be_Call_first_res + ARR_LEN(destroyed_regs),
n_ins, in, get_Call_type(irn));
}
/* The stack pointer will be modified in an unknown manner.
We cannot omit it. */
- env->call->flags.bits.try_omit_fp = 0;
+ env->call->flags.try_omit_fp = 0;
stack_alignment = 1 << arch_env->stack_alignment;
size = adjust_alloc_size(stack_alignment, size, block, dbg);
/* The stack pointer will be modified in an unknown manner.
We cannot omit it. */
- env->call->flags.bits.try_omit_fp = 0;
+ env->call->flags.try_omit_fp = 0;
subsp = be_new_SubSP(arch_env->sp, block, curr_sp, size);
set_irn_dbg_info(subsp, dbg);
unsigned long value = get_tarval_long(tv);
/* use ebp, so the climbframe algo works... */
if (value > 0) {
- env->call->flags.bits.try_omit_fp = 0;
+ env->call->flags.try_omit_fp = 0;
}
}
}
DBG((dbg, LEVEL_3, "\tprocessing call %+F\n", 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:
* Creates a be_Return for a Return node.
*
* @param @env the abi environment
- * @param irn the Return node or NULL if there was none
- * @param bl the block where the be_Retun should be placed
- * @param mem the current memory
- * @param n_res number of return results
+ * @param irn the Return node
*/
-static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl,
- ir_node *mem, int n_res)
+static ir_node *create_be_return(be_abi_irg_t *const env, ir_node *const irn)
{
+ ir_node *const bl = get_nodes_block(irn);
be_abi_call_t *call = env->call;
ir_graph *irg = get_Block_irg(bl);
const arch_env_t *arch_env = be_get_irg_arch_env(irg);
- dbg_info *dbgi;
pmap *reg_map = pmap_create();
ir_node *keep = pmap_get(ir_node, env->keep_map, bl);
size_t in_max;
- ir_node *ret;
int i, n;
- unsigned pop;
ir_node **in;
ir_node *stack;
const arch_register_t **regs;
remove_End_keepalive(get_irg_end(irg), keep);
}
+ int const n_res = get_Return_n_ress(irn);
/* Insert results for Return into the register map. */
for (i = 0; i < n_res; ++i) {
ir_node *res = get_Return_res(irn, i);
in = ALLOCAN(ir_node*, in_max);
regs = ALLOCAN(arch_register_t const*, in_max);
- in[0] = mem;
+ in[0] = get_Return_mem(irn);
in[1] = be_abi_reg_map_get(reg_map, arch_env->sp);
regs[0] = NULL;
regs[1] = arch_env->sp;
}
/* The in array for the new back end return is now ready. */
- if (irn != NULL) {
- dbgi = get_irn_dbg_info(irn);
- } else {
- dbgi = NULL;
- }
- /* we have to pop the shadow parameter in in case of struct returns */
- pop = call->pop;
- ret = be_new_Return(dbgi, irg, bl, n_res, pop, n, in);
+ dbg_info *const dbgi = get_irn_dbg_info(irn);
+ ir_node *const ret = be_new_Return(dbgi, irg, bl, n_res, call->pop, n, in);
/* Set the register classes of the return's parameter accordingly. */
for (i = 0; i < n; ++i) {
}
}
- stack_layout->sp_relative = call->flags.bits.try_omit_fp;
+ stack_layout->sp_relative = call->flags.try_omit_fp;
bet_type = call->cb->get_between_type(irg);
stack_frame_init(stack_layout, arg_type, bet_type,
get_irg_frame_type(irg));
}
}
- fp_reg = call->flags.bits.try_omit_fp ? arch_env->sp : arch_env->bp;
+ fp_reg = call->flags.try_omit_fp ? arch_env->sp : arch_env->bp;
rbitset_clear(birg->allocatable_regs, fp_reg->global_index);
/* handle start block here (place a jump in the block) */
ir_node *irn = get_Block_cfgpred(end, i);
if (is_Return(irn)) {
- ir_node *blk = get_nodes_block(irn);
- ir_node *mem = get_Return_mem(irn);
- ir_node *ret = create_be_return(env, irn, blk, mem, get_Return_n_ress(irn));
+ ir_node *const ret = create_be_return(env, irn);
exchange(irn, ret);
}
}
/* Break here if backend provides a custom API. */
- be_omit_fp = be_options.omit_fp;
-
be_abi_irg_t env;
env.keep_map = pmap_create();
- env.call = be_abi_call_new(arch_env->sp->reg_class);
+ env.call = be_abi_call_new();
arch_env_get_call_abi(arch_env, method_type, env.call);
env.init_sp = dummy;