#include "benode_t.h"
#include "belive_t.h"
#include "besched_t.h"
+#include "beirg.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. */
int pos;
const arch_register_t *reg;
- entity *stack_ent;
+ ir_entity *stack_ent;
unsigned alignment;
unsigned space_before;
unsigned space_after;
} be_abi_call_arg_t;
struct _be_abi_call_t {
- be_abi_call_flags_t flags;
- const be_abi_callbacks_t *cb;
- ir_type *between_type;
- set *params;
+ be_abi_call_flags_t flags;
+ const be_abi_callbacks_t *cb;
+ ir_type *between_type;
+ set *params;
+ const arch_register_class_t *cls_addr;
};
struct _be_abi_irg_t {
struct obstack obst;
be_stack_layout_t *frame; /**< The stack frame model. */
- const be_irg_t *birg; /**< The back end IRG. */
+ be_irg_t *birg; /**< The back end IRG. */
const arch_isa_t *isa; /**< The isa. */
survive_dce_t *dce_survivor;
ir_node *init_sp; /**< The node representing the stack pointer
at the start of the function. */
+ ir_node *start_barrier; /**< The barrier of the start block */
+
ir_node *reg_params; /**< The reg params node. */
pmap *regs; /**< A map of all callee-save and ignore regs to
their Projs to the RegParams node. */
/* Set the flags for a call. */
void be_abi_call_set_flags(be_abi_call_t *call, be_abi_call_flags_t flags, const be_abi_callbacks_t *cb)
{
- call->flags = flags;
- call->cb = cb;
+ call->flags = flags;
+ call->cb = cb;
}
+
+/* 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, unsigned alignment, unsigned space_before, unsigned space_after)
{
be_abi_call_arg_t *arg = get_or_set_call_arg(call, 0, arg_pos, 1);
static be_abi_call_t *be_abi_call_new(void)
{
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->cls_addr = NULL;
call->flags.bits.try_omit_fp = be_omit_fp;
+
return call;
}
and the spills.
*/
-static int get_stack_entity_offset(be_stack_layout_t *frame, 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_bytes(ent);
+ int ofs = get_entity_offset(ent);
int i, index;
/**
* Retrieve the entity with given offset from a frame type.
*/
-static entity *search_ent_with_offset(ir_type *t, int offset)
+static ir_entity *search_ent_with_offset(ir_type *t, int offset)
{
int i, n;
for(i = 0, n = get_compound_n_members(t); i < n; ++i) {
- entity *ent = get_compound_member(t, i);
- if(get_entity_offset_bytes(ent) == offset)
+ ir_entity *ent = get_compound_member(t, i);
+ if(get_entity_offset(ent) == offset)
return ent;
}
static int stack_frame_compute_initial_offset(be_stack_layout_t *frame)
{
- ir_type *base = frame->stack_dir < 0 ? frame->between_type : frame->frame_type;
- entity *ent = search_ent_with_offset(base, 0);
- frame->initial_offset = 0;
- frame->initial_offset = get_stack_entity_offset(frame, ent, 0);
+ ir_type *base = frame->stack_dir < 0 ? frame->between_type : frame->frame_type;
+ ir_entity *ent = search_ent_with_offset(base, 0);
+
+ frame->initial_offset = ent ? get_stack_entity_offset(frame, ent, 0) : 0;
+
return frame->initial_offset;
}
*/
static be_stack_layout_t *stack_frame_init(be_stack_layout_t *frame, ir_type *args,
ir_type *between, ir_type *locals, int stack_dir,
- entity *param_map[])
+ ir_entity *param_map[])
{
frame->arg_type = args;
frame->between_type = between;
ir_fprintf(file, "type %d: %F size: %d\n", j, t, get_type_size_bytes(t));
for (i = 0, n = get_compound_n_members(t); i < n; ++i) {
- entity *ent = get_compound_member(t, i);
+ ir_entity *ent = get_compound_member(t, i);
ir_fprintf(file, "\t%F int ofs: %d glob ofs: %d\n", ent, get_entity_offset_bytes(ent), get_stack_entity_offset(frame, ent, 0));
}
}
get_Call_type(irn));
/*
- TODO:
- Set the register class of the call address to the same as the stack pointer's.
- That' probably buggy for some architectures.
+ Set the register class of the call address to the same as the stack pointer's
+ if it's not set by the backend in the abi callback.
*/
- be_node_set_reg_class(low_call, be_pos_Call_ptr, sp->reg_class);
+ be_node_set_reg_class(low_call, be_pos_Call_ptr, call->cls_addr ? call->cls_addr : sp->reg_class);
+
+ /* Set input requirement for stack pointer. */
+ be_node_set_reg_class(low_call, be_pos_Call_sp, arch_get_irn_reg_class(isa->main_env->arch_env, curr_sp, -1));
DBG((env->dbg, LEVEL_3, "\tcreated backend call %+F\n", low_call));
*
* @return the stack argument layout type
*/
-static ir_type *compute_arg_type(be_abi_irg_t *env, be_abi_call_t *call, ir_type *method_type, entity ***param_map)
+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 i;
ir_type *val_param_tp = get_method_value_param_type(method_type);
ident *id = get_entity_ident(get_irg_entity(env->birg->irg));
- entity **map;
+ ir_entity **map;
- *param_map = map = obstack_alloc(&env->obst, n * sizeof(entity *));
+ *param_map = map = obstack_alloc(&env->obst, n * sizeof(ir_entity *));
res = new_type_struct(mangle_u(id, new_id_from_chars("arg_type", 8)));
for (i = 0; i < n; ++i, curr += inc) {
ir_type *param_type = get_method_param_type(method_type, curr);
}
ofs += arg->space_before;
ofs = round_up2(ofs, arg->alignment);
- set_entity_offset_bytes(arg->stack_ent, ofs);
+ set_entity_offset(arg->stack_ent, ofs);
ofs += arg->space_after;
ofs += get_type_size_bytes(param_type);
map[i] = arg->stack_ent;
typedef struct lower_frame_sels_env_t {
be_abi_irg_t *env;
- entity *value_param_list; /**< the list of all value param entities */
+ ir_entity *value_param_list; /**< the list of all value param entities */
} lower_frame_sels_env_t;
/**
if (ptr == frame || ptr == param_base) {
be_abi_irg_t *env = ctx->env;
- entity *ent = get_Sel_entity(irn);
+ ir_entity *ent = get_Sel_entity(irn);
ir_node *bl = get_nodes_block(irn);
ir_node *nw;
nw = be_new_FrameAddr(env->isa->sp->reg_class, irg, bl, frame, ent);
exchange(irn, nw);
- if (ptr == param_base) {
+ /* check, if it's a param sel and if have not seen this entity immediatly before */
+ if (ptr == param_base && ctx->value_param_list != ent) {
set_entity_link(ent, ctx->value_param_list);
ctx->value_param_list = ent;
}
* In the default case we move the entity to the frame type and create
* a backing store into the first block.
*/
-static void fix_address_of_parameter_access(be_abi_irg_t *env, entity *value_param_list) {
+static void fix_address_of_parameter_access(be_abi_irg_t *env, ir_entity *value_param_list) {
be_abi_call_t *call = env->call;
ir_graph *irg = env->birg->irg;
- entity *ent, *next_ent, *new_list;
+ ir_entity *ent, *next_ent, *new_list;
ir_type *frame_tp;
DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
add_class_member(frame_tp, ent);
/* must be automatic to set a fixed layout */
set_entity_allocation(ent, allocation_automatic);
- set_entity_offset_bytes(ent, offset);
+ set_entity_offset(ent, offset);
offset += get_type_size_bytes(tp);
}
set_type_size_bytes(frame_tp, offset);
const ir_edge_t *edge;
ir_type *arg_type, *bet_type;
lower_frame_sels_env_t ctx;
- entity **param_map;
+ ir_entity **param_map;
bitset_t *used_proj_nr;
DEBUG_ONLY(firm_dbg_module_t *dbg = env->dbg;)
pmap_insert(env->regs, (void *) isa->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));
/*
* make proj nodes for the callee save registers.
env->init_sp = be_new_IncSP(sp, irg, bl, env->init_sp, BE_STACK_FRAME_SIZE_EXPAND);
be_abi_reg_map_set(env->regs, sp, env->init_sp);
- barrier = create_barrier(env, bl, &mem, env->regs, 0);
+ env->start_barrier = barrier = create_barrier(env, 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);
arch_env_push_irn_handler(env->birg->main_env->arch_env, &env->irn_handler);
env->call->cb->done(env->cb);
+ env->cb = NULL;
return env;
}
void be_abi_fix_stack_nodes(be_abi_irg_t *env, be_lv_t *lv)
{
- dom_front_info_t *df;
pset *stack_nodes = pset_new_ptr(16);
struct fix_stack_walker_info info;
info.nodes = stack_nodes;
info.aenv = env->birg->main_env->arch_env;
- /* We need dominance frontiers for fix up */
- df = be_compute_dominance_frontiers(env->birg->irg);
+ be_assure_dom_front(env->birg);
+
irg_walk_graph(env->birg->irg, collect_stack_nodes_walker, NULL, &info);
pset_insert_ptr(stack_nodes, env->init_sp);
- be_ssa_constr_set_phis(df, lv, stack_nodes, env->stack_phis);
+ be_ssa_constr_set_phis(env->birg->dom_front, lv, stack_nodes, env->stack_phis);
del_pset(stack_nodes);
-
- /* free these dominance frontiers */
- be_free_dominance_frontiers(df);
}
static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias)
If so, set the true offset (including the bias) for that
node.
*/
- entity *ent = arch_get_frame_entity(arch_env, irn);
+ ir_entity *ent = arch_get_frame_entity(arch_env, irn);
if(ent) {
int offset = get_stack_entity_offset(env->frame, ent, bias);
arch_set_frame_offset(arch_env, irn, offset);
return pmap_get(abi->regs, (void *) reg);
}
+ir_node *be_abi_get_ignore_irn(be_abi_irg_t *abi, const arch_register_t *reg)
+{
+ assert(arch_register_type_is(reg, ignore));
+ assert(pmap_contains(abi->regs, (void *) reg));
+ return pmap_get(abi->regs, (void *) reg);
+}
+
+ir_node *be_abi_get_start_barrier(be_abi_irg_t *abi)
+{
+ return abi->start_barrier;
+}
+
/*
_____ _____ _ _ _ _ _ _
|_ _| __ \| \ | | | | | | | | |
return arch_irn_flags_ignore | arch_irn_flags_modify_sp;
}
-static entity *abi_get_frame_entity(const void *_self, const ir_node *irn)
+static ir_entity *abi_get_frame_entity(const void *_self, const ir_node *irn)
{
return NULL;
}
-static void abi_set_frame_entity(const void *_self, ir_node *irn, entity *ent)
+static void abi_set_frame_entity(const void *_self, ir_node *irn, ir_entity *ent)
{
}
static const arch_irn_handler_t abi_irn_handler = {
abi_get_irn_ops
};
+
+/**
+ * Returns non-zero if the ABI has omitted the frame pointer in
+ * the current graph.
+ */
+int be_abi_omit_fp(const be_abi_irg_t *abi) {
+ return abi->call->flags.bits.try_omit_fp;
+}
projects / libfirm / blobdiff