#include "iredges_t.h"
#include "irgmod.h"
#include "irgwalk.h"
-#include "irprintf_t.h"
+#include "irprintf.h"
#include "irgopt.h"
#include "iropt_t.h"
#include "irtools.h"
#include "be.h"
#include "beabi.h"
+#include "beabihelper.h"
#include "bearch.h"
#include "benode.h"
#include "belive_t.h"
typedef struct be_abi_call_arg_t {
unsigned is_res : 1; /**< 1: the call argument is a return value. 0: it's a call parameter. */
- unsigned in_reg : 1; /**< 1: this argument is transmitted in registers. */
- unsigned on_stack : 1; /**< 1: this argument is transmitted on the stack. */
+ unsigned in_reg : 1; /**< 1: this argument is transmitted 1: in registers, 0: on stack. */
unsigned callee : 1; /**< 1: someone called us. 0: We call another function */
int pos;
} 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;
};
/**
ir_node *init_sp; /**< The node representing the stack pointer
at the start of the function. */
- ir_node *start; /**< The be_Start params node. */
pmap *regs; /**< A map of all callee-save and ignore regs to
their Projs to the RegParams node. */
- int start_block_bias; /**< The stack bias at the end of the start block. */
-
pmap *keep_map; /**< mapping blocks to keep nodes. */
ir_node **calls; /**< flexible array containing all be_Call nodes */
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);
}
/**
- * Check if the given register is callee save, ie. will be saved by the callee.
+ * Check if the given register is callee save, i.e. will be saved by the callee.
*/
static bool arch_register_is_callee_save(
const arch_env_t *arch_env,
}
/**
- * Check if the given register is caller save, ie. must be saved by the caller.
+ * Check if the given register is caller save, i.e. must be saved by the caller.
*/
static bool arch_register_is_caller_save(
const arch_env_t *arch_env,
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,
be_abi_call_arg_t arg;
memset(&arg, 0, sizeof(arg));
assert(alignment > 0 && "Alignment must be greater than 0");
- arg.on_stack = 1;
arg.load_mode = load_mode;
arg.alignment = alignment;
arg.space_before = space_before;
/**
* 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);
for (p = 0; p < n_params; ++p) {
be_abi_call_arg_t *arg = get_call_arg(call, 0, p, 0);
assert(arg);
- if (arg->on_stack) {
+ if (!arg->in_reg) {
int arg_size = get_type_size_bytes(get_method_param_type(call_tp, p));
stack_size += round_up2(arg->space_before, arg->alignment);
* checking */
continue;
}
- if (arch_register_is_caller_save(arch_env, reg)) {
- if (!(reg->type & arch_register_type_ignore)) {
- ARR_APP1(const arch_register_t*, destroyed_regs, reg);
- }
- }
+ if (arch_register_is_caller_save(arch_env, reg))
+ ARR_APP1(const arch_register_t*, destroyed_regs, reg);
}
}
continue;
foreach_out_edge(irn, res_edge) {
- int proj;
- ir_node *res = get_edge_src_irn(res_edge);
-
- assert(is_Proj(res));
-
- proj = get_Proj_proj(res);
+ ir_node *const res = get_edge_src_irn(res_edge);
+ long const proj = get_Proj_proj(res);
assert(proj < n_res);
assert(res_projs[proj] == NULL);
res_projs[proj] = res;
/* 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,
+ low_call = be_new_Call(dbgi, bl, curr_mem, sp->single_req, curr_sp,
sp->single_req, curr_sp,
n_reg_results + pn_be_Call_first_res + ARR_LEN(destroyed_regs),
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(dbgi, irg, bl, curr_mem, sp->single_req, curr_sp,
- call->cls_addr->class_req, call_ptr,
+ low_call = be_new_Call(dbgi, bl, curr_mem, sp->single_req, curr_sp,
+ 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));
}
keep = be_new_Keep(bl, n, in);
for (i = 0; i < n; ++i) {
const arch_register_t *reg = (const arch_register_t*)get_irn_link(in[i]);
- be_node_set_reg_class_in(keep, i, arch_register_get_class(reg));
+ be_node_set_reg_class_in(keep, i, reg->reg_class);
}
}
foreach_out_edge(alloc, edge) {
ir_node *irn = get_edge_src_irn(edge);
- assert(is_Proj(irn));
switch (get_Proj_proj(irn)) {
case pn_Alloc_M:
alloc_mem = 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:
/**
* Adjust all call nodes in the graph to the ABI conventions.
*/
-static void process_calls(ir_graph *irg)
+static void process_calls(ir_graph *const irg, be_abi_irg_t *const abi)
{
- be_abi_irg_t *abi = be_get_irg_abi(irg);
-
irg_walk_graph(irg, firm_clear_link, link_ops_in_block_walker, abi);
ir_heights = heights_new(irg);
if (map[num] != NULL)
panic("multiple entities for parameter %u in %+F found", f, irg);
- if (num != n_params && !get_call_arg(call, 0, num, 1)->on_stack) {
+ if (num != n_params && get_call_arg(call, 0, num, 1)->in_reg) {
/* don't move this entity */
continue;
}
ir_type *param_type = get_method_param_type(method_type, i);
ir_entity *entity;
- if (!arg->on_stack) {
+ if (arg->in_reg)
continue;
- }
entity = map[i];
if (entity == NULL) {
/* create a new entity */
return res;
}
-typedef struct {
- const arch_register_t *reg;
- ir_node *irn;
-} reg_node_map_t;
-
static int cmp_regs(const void *a, const void *b)
{
- const reg_node_map_t *p = (const reg_node_map_t*)a;
- const reg_node_map_t *q = (const reg_node_map_t*)b;
+ arch_register_t const *const p = *(arch_register_t const**)a;
+ arch_register_t const *const q = *(arch_register_t const**)b;
- if (p->reg->reg_class == q->reg->reg_class)
- return p->reg->index - q->reg->index;
+ if (p->reg_class == q->reg_class)
+ return p->index - q->index;
else
- return p->reg->reg_class < q->reg->reg_class ? -1 : +1;
+ return p->reg_class < q->reg_class ? -1 : +1;
}
-static void reg_map_to_arr(reg_node_map_t *res, pmap *reg_map)
+static void reg_map_to_arr(arch_register_t const **const res, pmap *const reg_map)
{
pmap_entry *ent;
size_t n = pmap_count(reg_map);
size_t i = 0;
foreach_pmap(reg_map, ent) {
- res[i].reg = (const arch_register_t*)ent->key;
- res[i].irn = (ir_node*)ent->value;
- i++;
+ res[i++] = (arch_register_t const*)ent->key;
}
qsort(res, n, sizeof(res[0]), cmp_regs);
* 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);
/* Add uses of the callee save registers. */
foreach_pmap(env->regs, ent) {
const arch_register_t *reg = (const arch_register_t*)ent->key;
- if ((reg->type & arch_register_type_ignore) || arch_register_is_callee_save(arch_env, reg))
+ if (arch_register_is_callee_save(arch_env, reg))
pmap_insert(reg_map, ent->key, ent->value);
}
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, bl, n_res, call->pop, n, in);
/* Set the register classes of the return's parameter accordingly. */
for (i = 0; i < n; ++i) {
typedef struct lower_frame_sels_env_t {
ir_node *frame; /**< the current frame */
const arch_register_class_t *sp_class; /**< register class of the stack pointer */
- const arch_register_class_t *link_class; /**< register class of the link pointer */
- ir_type *frame_tp; /**< the frame type */
- int static_link_pos; /**< argument number of the hidden static link */
} lower_frame_sels_env_t;
/**
/**
* Modify the irg itself and the frame type.
*/
-static void modify_irg(ir_graph *irg)
+static void modify_irg(ir_graph *const irg, be_abi_irg_t *const env)
{
- be_abi_irg_t *env = be_get_irg_abi(irg);
be_abi_call_t *call = env->call;
const arch_env_t *arch_env = be_get_irg_arch_env(irg);
const arch_register_t *sp = arch_env->sp;
int n_params;
int i, n;
unsigned j;
- unsigned frame_size;
- reg_node_map_t *rm;
const arch_register_t *fp_reg;
ir_node *frame_pointer;
ir_node *start_bl;
arg_type = compute_arg_type(irg, call, method_type);
/* Convert the Sel nodes in the irg to frame addr nodes: */
- ctx.frame = get_irg_frame(irg);
- ctx.sp_class = arch_env->sp->reg_class;
- ctx.link_class = arch_env->link_class;
- ctx.frame_tp = get_irg_frame_type(irg);
+ ctx.frame = get_irg_frame(irg);
+ ctx.sp_class = arch_env->sp->reg_class;
+ ir_type *const frame_tp = get_irg_frame_type(irg);
/* layout the stackframe now */
- if (get_type_state(ctx.frame_tp) == layout_undefined) {
- default_layout_compound_type(ctx.frame_tp);
+ if (get_type_state(frame_tp) == layout_undefined) {
+ default_layout_compound_type(frame_tp);
}
- /* align stackframe to 4 byte */
- frame_size = get_type_size_bytes(ctx.frame_tp);
- if (frame_size % 4 != 0) {
- set_type_size_bytes(ctx.frame_tp, frame_size + 4 - (frame_size % 4));
- }
+ /* align stackframe */
+ unsigned const alignment = 1U << arch_env->stack_alignment;
+ unsigned const frame_size = round_up2(get_type_size_bytes(frame_tp), alignment);
+ set_type_size_bytes(frame_tp, frame_size);
env->regs = pmap_create();
}
}
- 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) */
pmap_insert(env->regs, (void *) sp, NULL);
pmap_insert(env->regs, (void *) arch_env->bp, NULL);
start_bl = get_irg_start_block(irg);
- env->start = be_new_Start(NULL, start_bl, pmap_count(env->regs) + 1);
- set_irg_start(irg, env->start);
+ ir_node *const start = be_new_Start(NULL, start_bl, pmap_count(env->regs) + 1);
+ set_irg_start(irg, start);
/*
* make proj nodes for the callee save registers.
* Note, that if a register corresponds to an argument, the regs map
* contains the old Proj from start for that argument.
*/
- rm = ALLOCAN(reg_node_map_t, pmap_count(env->regs));
- reg_map_to_arr(rm, env->regs);
+ arch_register_t const **const regs = ALLOCAN(arch_register_t const*, pmap_count(env->regs));
+ reg_map_to_arr(regs, env->regs);
for (i = 0, n = pmap_count(env->regs); i < n; ++i) {
- const arch_register_t *reg = rm[i].reg;
+ const arch_register_t *reg = regs[i];
ir_mode *mode = reg->reg_class->mode;
long nr = i;
arch_register_req_type_t add_type = arch_register_req_type_none;
}
assert(nr >= 0);
- proj = new_r_Proj(env->start, mode, nr + 1);
+ proj = new_r_Proj(start, mode, nr + 1);
pmap_insert(env->regs, (void *) reg, proj);
- be_set_constr_single_reg_out(env->start, nr + 1, reg, add_type);
+ be_set_constr_single_reg_out(start, nr + 1, reg, add_type);
arch_set_irn_register(proj, reg);
DBG((dbg, LEVEL_2, "\tregister save proj #%d -> reg %s\n", nr, reg->name));
/* create a new initial memory proj */
assert(is_Proj(old_mem));
- arch_set_irn_register_req_out(env->start, 0, arch_no_register_req);
- new_mem_proj = new_r_Proj(env->start, mode_M, 0);
+ arch_set_irn_register_req_out(start, 0, arch_no_register_req);
+ new_mem_proj = new_r_Proj(start, mode_M, 0);
mem = new_mem_proj;
set_irg_initial_mem(irg, mem);
if (arg->in_reg) {
repl = pmap_get(ir_node, env->regs, arg->reg);
- } else if (arg->on_stack) {
+ } else {
ir_node *addr = be_new_FrameAddr(sp->reg_class, start_bl, frame_pointer, arg->stack_ent);
/* For atomic parameters which are actually used, we create a Load node. */
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);
}
}
}
/** Fix the state inputs of calls that still hang on unknowns */
-static void fix_call_state_inputs(ir_graph *irg)
+static void fix_call_state_inputs(ir_graph *const irg, be_abi_irg_t *const env)
{
- be_abi_irg_t *env = be_get_irg_abi(irg);
const arch_env_t *arch_env = be_get_irg_arch_env(irg);
int i, n, n_states;
arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0);
void be_abi_introduce(ir_graph *irg)
{
- be_abi_irg_t *env = XMALLOCZ(be_abi_irg_t);
ir_node *old_frame = get_irg_frame(irg);
const arch_env_t *arch_env = be_get_irg_arch_env(irg);
ir_entity *entity = get_irg_entity(irg);
}
}
- /* break here if backend provides a custom API.
- * Note: we shouldn't have to setup any be_abi_irg_t* stuff at all,
- * but need more cleanup to make this work
- */
- be_set_irg_abi(irg, env);
+ /* 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_get_call_abi(arch_env, method_type, env.call);
- env->keep_map = pmap_create();
- env->call = be_abi_call_new(arch_env->sp->reg_class);
- arch_env_get_call_abi(arch_env, method_type, env->call);
-
- env->init_sp = dummy;
- env->calls = NEW_ARR_F(ir_node*, 0);
+ env.init_sp = dummy;
+ env.calls = NEW_ARR_F(ir_node*, 0);
assure_edges(irg);
if (be_options.pic) {
- irg_walk_graph(irg, fix_pic_symconsts, NULL, env);
+ irg_walk_graph(irg, fix_pic_symconsts, NULL, NULL);
}
/* Lower all call nodes in the IRG. */
- process_calls(irg);
+ process_calls(irg, &env);
/* Process the IRG */
- modify_irg(irg);
+ modify_irg(irg, &env);
/* fix call inputs for state registers */
- fix_call_state_inputs(irg);
+ fix_call_state_inputs(irg, &env);
+
+ be_abi_call_free(env.call);
/* We don't need the keep map anymore. */
- pmap_destroy(env->keep_map);
- env->keep_map = NULL;
+ pmap_destroy(env.keep_map);
/* calls array is not needed anymore */
- DEL_ARR_F(env->calls);
- env->calls = NULL;
+ DEL_ARR_F(env.calls);
/* reroute the stack origin of the calls to the true stack origin. */
- exchange(dummy, env->init_sp);
+ exchange(dummy, env.init_sp);
exchange(old_frame, get_irg_frame(irg));
- pmap_destroy(env->regs);
- env->regs = NULL;
-}
-
-void be_abi_free(ir_graph *irg)
-{
- be_abi_irg_t *env = be_get_irg_abi(irg);
-
- if (env->call != NULL)
- be_abi_call_free(env->call);
- assert(env->regs == NULL);
- free(env);
-
- be_set_irg_abi(irg, NULL);
+ pmap_destroy(env.regs);
}
void be_put_allocatable_regs(const ir_graph *irg,
projects / libfirm / blobdiff