* @date 7.3.2005
* @cvsid $Id$
*/
-
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "height.h"
#include "pdeq.h"
#include "irtools.h"
+#include "raw_bitset.h"
#include "be.h"
#include "beabi.h"
-#include "bearch.h"
+#include "bearch_t.h"
#include "benode_t.h"
#include "belive_t.h"
#include "besched_t.h"
+#include "beirg_t.h"
+#include "bessaconstr.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;
pmap *regs; /**< A map of all callee-save and ignore regs to
their Projs to the RegParams node. */
- pset *stack_phis; /**< The set of all Phi nodes inserted due to
- stack pointer modifying nodes. */
-
int start_block_bias; /**< The stack bias at the end of the start block. */
void *cb; /**< ABI Callback self pointer. */
pmap *keep_map; /**< mapping blocks to keep nodes. */
pset *ignore_regs; /**< Additional registers which shall be ignored. */
- arch_irn_handler_t irn_handler;
- arch_irn_ops_t irn_ops;
+ ir_node **calls; /**< flexible array containing all be_Call nodes */
+
+ arch_register_req_t sp_req;
+ arch_register_req_t sp_cls_req;
+
DEBUG_ONLY(firm_dbg_module_t *dbg;) /**< The debugging module. */
};
-#define get_abi_from_handler(ptr) firm_container_of(ptr, be_abi_irg_t, irn_handler)
-#define get_abi_from_ops(ptr) firm_container_of(ptr, be_abi_irg_t, irn_ops)
-
-/* Forward, since be need it in be_abi_introduce(). */
-static const arch_irn_ops_if_t abi_irn_ops;
-static const arch_irn_handler_t abi_irn_handler;
static heights_t *ir_heights;
/* Flag: if set, try to omit the frame pointer if called by the backend */
*
* @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(const arch_register_class_t *cls_addr)
{
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->cls_addr = cls_addr;
call->flags.bits.try_omit_fp = be_omit_fp;
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);
+ 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;
*/
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));
}
}
static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, ir_node *alloca_copy)
{
ir_graph *irg = env->birg->irg;
- const arch_isa_t *isa = env->birg->main_env->arch_env->isa;
- be_abi_call_t *call = be_abi_call_new();
+ const arch_env_t *arch_env = env->birg->main_env->arch_env;
+ const arch_isa_t *isa = arch_env->isa;
ir_type *mt = get_Call_type(irn);
ir_node *call_ptr = get_Call_ptr(irn);
int n_params = get_method_n_params(mt);
ir_node *bl = get_nodes_block(irn);
pset *results = pset_new_ptr(8);
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);
+ 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 curr_res_proj = pn_Call_max;
int n_low_args = 0;
int n_pos = 0;
+ int count;
ir_node *low_call;
ir_node **in;
ir_node **res_projs;
+ const arch_register_t *reg;
const ir_edge_t *edge;
int *low_args;
int *pos;
/*
* 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
+ * We must them reverse again if 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) {
+ for (i = 0; i < n_pos >> 1; ++i) {
int other = n_pos - i - 1;
int tmp = pos[i];
pos[i] = pos[other];
curr_mem = get_Call_mem(irn);
}
- assert(mode_is_reference(mach_mode) && "machine mode must be pointer");
for(i = 0; i < n_pos; ++i) {
int p = pos[i];
be_abi_call_arg_t *arg = get_call_arg(call, 0, p);
/* Make the expression to compute the argument's offset. */
if(curr_ofs > 0) {
- addr = new_r_Const_long(irg, bl, mode_Is, curr_ofs);
+ ir_mode *constmode = mach_mode;
+ if(mode_is_reference(mach_mode)) {
+ constmode = mode_Is;
+ }
+ addr = new_r_Const_long(irg, bl, constmode, curr_ofs);
addr = new_r_Add(irg, bl, curr_sp, addr, mach_mode);
}
}
const arch_register_class_t *cls = arch_isa_get_reg_class(isa, 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))
+ if(arch_register_type_is(reg, caller_save)) {
pset_insert_ptr(caller_save, (void *) reg);
+ }
+ if(arch_register_type_is(reg, state)) {
+ pset_insert_ptr(caller_save, (void*) reg);
+ pset_insert_ptr(states, (void*) reg);
+ }
}
}
res_projs = obstack_finish(obst);
/* make the back end call node and set its register requirements. */
- for(i = 0; i < n_low_args; ++i)
+ for(i = 0; i < n_low_args; ++i) {
obstack_ptr_grow(obst, get_Call_param(irn, low_args[i]));
+ }
+ foreach_pset(states, reg) {
+ const arch_register_class_t *cls = arch_register_get_class(reg);
+#if 0
+ ir_node *regnode = be_abi_reg_map_get(env->regs, reg);
+ ir_fprintf(stderr, "Adding %+F\n", regnode);
+#endif
+ ir_node *regnode = new_rd_Unknown(irg, arch_register_class_mode(cls));
+ obstack_ptr_grow(obst, regnode);
+ }
+ count = n_low_args + pset_count(states);
in = obstack_finish(obst);
if(env->call->flags.bits.call_has_imm && get_irn_opcode(call_ptr) == iro_SymConst) {
- low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem, curr_sp, curr_sp,
- curr_res_proj + pset_count(caller_save), n_low_args, in,
- get_Call_type(irn));
+ low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem,
+ curr_sp, curr_sp,
+ curr_res_proj + pset_count(caller_save), count,
+ in, get_Call_type(irn));
be_Call_set_entity(low_call, get_SymConst_entity(call_ptr));
+ } else {
+ low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem,
+ curr_sp, call_ptr,
+ curr_res_proj + pset_count(caller_save),
+ count, in, get_Call_type(irn));
}
-
- else
- low_call = be_new_Call(get_irn_dbg_info(irn), irg, bl, curr_mem, curr_sp, call_ptr,
- curr_res_proj + pset_count(caller_save), n_low_args, in,
- get_Call_type(irn));
+ ARR_APP1(ir_node*, env->calls, low_call);
/*
- 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.
+ Set the register class of the call address to
+ the backend provided class (default: stack pointer 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));
+ be_node_set_reg_class(low_call, be_pos_Call_ptr, call->cls_addr);
DBG((env->dbg, LEVEL_3, "\tcreated backend call %+F\n", low_call));
}
/* Set the register constraints of the results. */
- for(i = 0; res_projs[i]; ++i) {
- ir_node *irn = res_projs[i];
- int proj = get_Proj_proj(irn);
+ for (i = 0; res_projs[i]; ++i) {
+ int pn = get_Proj_proj(res_projs[i]);
/* Correct Proj number since it has been adjusted! (see above) */
- const be_abi_call_arg_t *arg = get_call_arg(call, 1, proj - pn_Call_max);
+ const be_abi_call_arg_t *arg = get_call_arg(call, 1, pn - pn_Call_max);
+
+ /* Matze: we need the information about the real mode for later
+ * transforms (signed/unsigend compares, stores...), so leave the fixup
+ * for the backend transform phase... */
+#if 0
+ /* correct mode */
+ const arch_register_class_t *cls = arch_register_get_class(arg->reg);
+ ir_mode *mode = arch_register_class_mode(cls);
+ set_irn_mode(irn, mode);
+#endif
assert(arg->in_reg);
- be_set_constr_single_reg(low_call, BE_OUT_POS(proj), arg->reg);
+ be_set_constr_single_reg(low_call, BE_OUT_POS(pn), arg->reg);
+ arch_set_irn_register(arch_env, res_projs[i], arg->reg);
}
obstack_free(obst, in);
exchange(irn, low_call);
/* redirect the result projs to the lowered call instead of the Proj_T */
- for(i = 0; res_projs[i]; ++i)
+ for (i = 0; res_projs[i]; ++i)
set_Proj_pred(res_projs[i], low_call);
+ /* set the now unnecessary projT to bad */
+ if(res_proj != NULL) {
+ be_kill_node(res_proj);
+ }
+
/* Make additional projs for the caller save registers
and the Keep node which keeps them alive. */
- if(pset_count(caller_save) > 0) {
+ if (pset_count(caller_save) > 0) {
const arch_register_t *reg;
- ir_node **in, *keep;
- int i, n;
+ ir_node **in, *keep;
+ int i, n;
- for(reg = pset_first(caller_save), n = 0; reg; reg = pset_next(caller_save), ++n) {
+ for (reg = pset_first(caller_save), n = 0; reg; reg = pset_next(caller_save), ++n) {
ir_node *proj = new_r_Proj(irg, bl, low_call, reg->reg_class->mode, curr_res_proj);
/* memorize the register in the link field. we need afterwards to set the register class of the keep correctly. */
be_set_constr_single_reg(low_call, BE_OUT_POS(curr_res_proj), reg);
+
+ /* a call can produce ignore registers, in this case set the flag and register for the Proj */
+ if (arch_register_type_is(reg, ignore)) {
+ arch_set_irn_register(env->birg->main_env->arch_env, proj, reg);
+ be_node_set_flags(low_call, BE_OUT_POS(curr_res_proj), arch_irn_flags_ignore);
+ }
+
set_irn_link(proj, (void *) reg);
obstack_ptr_grow(obst, proj);
curr_res_proj++;
}
+ /* create the Keep for the caller save registers */
in = (ir_node **) obstack_finish(obst);
keep = be_new_Keep(NULL, irg, bl, n, in);
- for(i = 0; i < n; ++i) {
+ for (i = 0; i < n; ++i) {
const arch_register_t *reg = get_irn_link(in[i]);
be_node_set_reg_class(keep, i, reg->reg_class);
}
be_abi_call_free(call);
obstack_free(obst, pos);
del_pset(results);
+ del_pset(states);
del_pset(caller_save);
return curr_sp;
*/
static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp, ir_node **result_copy)
{
- if (get_Alloc_where(alloc) == stack_alloc) {
- ir_node *bl = get_nodes_block(alloc);
- ir_graph *irg = get_irn_irg(bl);
- ir_node *alloc_mem = NULL;
- ir_node *alloc_res = NULL;
+ ir_node *block;
+ ir_graph *irg;
+ ir_node *alloc_mem;
+ ir_node *alloc_res;
+ ir_type *type;
- const ir_edge_t *edge;
- ir_node *new_alloc;
- ir_node *addr;
- ir_node *copy;
- ir_node *ins[2];
+ const ir_edge_t *edge;
+ ir_node *new_alloc;
+ ir_node *size;
+ ir_node *addr;
+ ir_node *copy;
+ ir_node *ins[2];
+
+ if (get_Alloc_where(alloc) != stack_alloc) {
+ assert(0);
+ return alloc;
+ }
- foreach_out_edge(alloc, edge) {
- ir_node *irn = get_edge_src_irn(edge);
+ block = get_nodes_block(alloc);
+ irg = get_irn_irg(block);
+ alloc_mem = NULL;
+ alloc_res = NULL;
+ type = get_Alloc_type(alloc);
- assert(is_Proj(irn));
- switch(get_Proj_proj(irn)) {
- case pn_Alloc_M:
- alloc_mem = irn;
- break;
- case pn_Alloc_res:
- alloc_res = irn;
- break;
- default:
- break;
- }
- }
+ foreach_out_edge(alloc, edge) {
+ ir_node *irn = get_edge_src_irn(edge);
- /* 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 && alloc_mem) {
- exchange(alloc_mem, get_Alloc_mem(alloc));
- return curr_sp;
+ assert(is_Proj(irn));
+ switch(get_Proj_proj(irn)) {
+ case pn_Alloc_M:
+ alloc_mem = irn;
+ break;
+ case pn_Alloc_res:
+ alloc_res = irn;
+ break;
+ default:
+ break;
}
+ }
- /* 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));
+ /* 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 && alloc_mem) {
+ exchange(alloc_mem, get_Alloc_mem(alloc));
+ return curr_sp;
+ }
- if(alloc_mem != NULL) {
- ir_node *addsp_mem;
- ir_node *sync;
+ /* we might need to multiply the size with the element size */
+ if(type != get_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(NULL, irg, block, mode_Iu, tv);
+ ir_node *mul = new_rd_Mul(NULL, irg, block, get_Alloc_size(alloc),
+ cnst, mode_Iu);
+ size = mul;
+ } else {
+ size = get_Alloc_size(alloc);
+ }
- addsp_mem = new_r_Proj(irg, bl, new_alloc, mode_M, pn_be_AddSP_M);
+ /* 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, block, curr_sp, size);
- // We need to sync the output mem of the AddSP with the input mem
- // edge into the alloc node
- ins[0] = get_Alloc_mem(alloc);
- ins[1] = addsp_mem;
- sync = new_r_Sync(irg, bl, 2, ins);
+ if(alloc_mem != NULL) {
+ ir_node *addsp_mem;
+ ir_node *sync;
- exchange(alloc_mem, sync);
- }
+ addsp_mem = new_r_Proj(irg, block, new_alloc, mode_M, pn_be_AddSP_M);
- exchange(alloc, new_alloc);
+ // We need to sync the output mem of the AddSP with the input mem
+ // edge into the alloc node
+ ins[0] = get_Alloc_mem(alloc);
+ ins[1] = addsp_mem;
+ sync = new_r_Sync(irg, block, 2, ins);
- /* fix projnum of alloca res */
- set_Proj_proj(alloc_res, pn_be_AddSP_res);
+ exchange(alloc_mem, sync);
+ }
- addr = env->isa->stack_dir < 0 ? alloc_res : curr_sp;
+ exchange(alloc, new_alloc);
- /* copy the address away, since it could be used after further stack pointer modifications. */
- /* Let it point curr_sp just for the moment, I'll reroute it in a second. */
- *result_copy = copy = be_new_Copy(env->isa->sp->reg_class, irg, bl, curr_sp);
+ /* fix projnum of alloca res */
+ set_Proj_proj(alloc_res, pn_be_AddSP_res);
- /* Let all users of the Alloc() result now point to the copy. */
- edges_reroute(alloc_res, copy, irg);
+ addr = env->isa->stack_dir < 0 ? alloc_res : curr_sp;
- /* Rewire the copy appropriately. */
- set_irn_n(copy, be_pos_Copy_op, addr);
+ /* copy the address away, since it could be used after further stack pointer modifications. */
+ /* Let it point curr_sp just for the moment, I'll reroute it in a second. */
+ *result_copy = copy = be_new_Copy(env->isa->sp->reg_class, irg, block, curr_sp);
+
+ /* Let all users of the Alloc() result now point to the copy. */
+ edges_reroute(alloc_res, copy, irg);
+
+ /* Rewire the copy appropriately. */
+ set_irn_n(copy, be_pos_Copy_op, addr);
+
+ curr_sp = alloc_res;
- curr_sp = alloc_res;
- }
return curr_sp;
} /* adjust_alloc */
*/
static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp)
{
- if (get_Free_where(free) == stack_alloc) {
- ir_node *bl = get_nodes_block(free);
- ir_graph *irg = get_irn_irg(bl);
- ir_node *addsp, *mem, *res;
+ ir_node *block;
+ ir_graph *irg;
+ ir_node *subsp, *mem, *res, *size, *sync;
+ ir_type *type;
+ ir_node *in[2];
+ ir_mode *sp_mode;
+
+ if (get_Free_where(free) != stack_alloc) {
+ assert(0);
+ return free;
+ }
- /* The stack pointer will be modified in an unknown manner.
- We cannot omit it. */
- env->call->flags.bits.try_omit_fp = 0;
- addsp = be_new_SubSP(env->isa->sp, irg, bl, curr_sp, get_Free_size(free));
+ block = get_nodes_block(free);
+ irg = get_irn_irg(block);
+ type = get_Free_type(free);
+ sp_mode = env->isa->sp->reg_class->mode;
+
+ /* we might need to multiply the size with the element size */
+ if(type != get_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(NULL, irg, block, mode_Iu, tv);
+ ir_node *mul = new_rd_Mul(NULL, irg, block, get_Free_size(free),
+ cnst, mode_Iu);
+ size = mul;
+ } else {
+ size = get_Free_size(free);
+ }
- mem = new_r_Proj(irg, bl, addsp, mode_M, pn_be_SubSP_M);
- res = new_r_Proj(irg, bl, addsp, mode_P_data, pn_be_SubSP_res);
+ /* 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);
+
+ mem = new_r_Proj(irg, block, subsp, mode_M, pn_be_SubSP_M);
+ res = new_r_Proj(irg, block, subsp, sp_mode, pn_be_SubSP_res);
+
+ /* we need to sync the memory */
+ in[0] = get_Free_mem(free);
+ in[1] = mem;
+ sync = new_r_Sync(irg, block, 2, in);
+
+ /* and make the AddSP dependent on the former memory */
+ add_irn_dep(subsp, get_Free_mem(free));
+
+ /* kill the free */
+ exchange(free, sync);
+ curr_sp = res;
- exchange(free, mem);
- curr_sp = res;
- }
return curr_sp;
} /* adjust_free */
*/
static int dependent_on(ir_node *n1, ir_node *n2)
{
- ir_node *bl = get_nodes_block(n1);
-
- assert(bl == get_nodes_block(n2));
+ assert(get_nodes_block(n1) == get_nodes_block(n2));
return heights_reachable_in_block(ir_heights, n1, n2);
- //return check_dependence(n1, n2, bl);
}
static int cmp_call_dependecy(const void *c1, const void *c2)
*/
static void link_calls_in_block_walker(ir_node *irn, void *data)
{
- opcode code = get_irn_opcode(irn);
+ ir_opcode code = get_irn_opcode(irn);
if (code == iro_Call ||
(code == iro_Alloc && get_Alloc_where(irn) == stack_alloc) ||
*
* @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;
* 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);
}
}
+/**
+ * The start block has no jump, instead it has an initial exec Proj.
+ * The backend wants to handle all blocks the same way, so we replace
+ * the out cfg edge with a real jump.
+ */
+static void fix_start_block(ir_node *block, void *env) {
+ int *done = env;
+ int i;
+ ir_node *start_block;
+ ir_graph *irg;
+
+ /* we processed the start block, return */
+ if (*done)
+ return;
+
+ irg = get_irn_irg(block);
+ start_block = get_irg_start_block(irg);
+
+ for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) {
+ ir_node *pred = get_Block_cfgpred(block, i);
+ ir_node *pred_block = get_nodes_block(pred);
+
+ /* ok, we are in the block, having start as cfg predecessor */
+ if (pred_block == start_block) {
+ ir_node *jump = new_r_Jmp(irg, pred_block);
+ set_Block_cfgpred(block, i, jump);
+ *done = 1;
+ }
+ }
+}
+
/**
* Modify the irg itself and the frame type.
*/
ir_graph *irg = env->birg->irg;
ir_node *bl = get_irg_start_block(irg);
ir_node *end = get_irg_end_block(irg);
- ir_node *mem = get_irg_initial_mem(irg);
+ ir_node *old_mem = get_irg_initial_mem(irg);
+ 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, j, n;
+ int i, j, n, temp;
reg_node_map_t *rm;
const arch_register_t *fp_reg;
ir_node *reg_params_bl;
ir_node **args;
ir_node *arg_tuple;
+ ir_node *value_param_base;
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;)
ctx.value_param_list = NULL;
irg_walk_graph(irg, lower_frame_sels_walker, NULL, &ctx);
+ /* value_param_base anchor is not needed anymore now */
+ value_param_base = get_irg_value_param_base(irg);
+ be_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();
const arch_register_class_t *cls = arch_isa_get_reg_class(isa, 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) || arch_register_type_is(reg, ignore))
+ if(arch_register_type_is(reg, callee_save) ||
+ arch_register_type_is(reg, state)) {
pmap_insert(env->regs, (void *) reg, NULL);
+ }
}
}
rm = reg_map_to_arr(&env->obst, env->regs);
for(i = 0, n = pmap_count(env->regs); i < n; ++i) {
arch_register_t *reg = (void *) rm[i].reg;
- ir_node *arg_proj = rm[i].irn;
- ir_mode *mode = arg_proj ? get_irn_mode(arg_proj) : reg->reg_class->mode;
+ ir_mode *mode = reg->reg_class->mode;
long nr = i;
int pos = BE_OUT_POS((int) nr);
int flags = 0;
}
obstack_free(&env->obst, rm);
+ /* create a new initial memory proj */
+ 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,
+ get_Proj_proj(old_mem));
+ mem = new_mem_proj;
+
/* Generate the Prologue */
fp_reg = call->cb->prologue(env->cb, &mem, env->regs);
/* 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_abi_reg_map_get(env->regs, sp);
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);
env->start_barrier = barrier = create_barrier(env, bl, &mem, env->regs, 0);
- env->init_sp = be_abi_reg_map_get(env->regs, sp);
+ 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);
frame_pointer = be_abi_reg_map_get(env->regs, fp_reg);
set_irg_frame(irg, frame_pointer);
pset_insert_ptr(env->ignore_regs, fp_reg);
+ /* rewire old mem users to new mem */
+ set_Proj_pred(new_mem_proj, get_Proj_pred(old_mem));
+ exchange(old_mem, mem);
+
+ 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) {
ir_node *arg_proj = args[i];
}
assert(repl != NULL);
- edges_reroute(args[i], repl, irg);
+ exchange(args[i], repl);
}
}
+ /* the arg proj is not needed anymore now */
+ assert(get_irn_n_edges(arg_tuple) == 0);
+ be_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. */
for (i = 0, n = get_Block_n_cfgpreds(end); i < n; ++i) {
ir_node *irn = get_Block_cfgpred(end, i);
exchange(irn, ret);
}
}
- /* if we have endless loops here, n might be <= 0. Do NOT create a be_Return than,
+ /* 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) */
+ temp = 0;
+ irg_block_walk_graph(irg, fix_start_block, NULL, &temp);
+}
+
+/** Fix the state inputs of calls that still hang on unknowns */
+static
+void fix_call_state_inputs(be_abi_irg_t *env)
+{
+ const arch_isa_t *isa = env->isa;
+ 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) {
+ int 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_t *reg = arch_register_for_index(cls, j);
+ 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) {
+ 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) {
+ 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);
+ }
+ }
}
be_abi_irg_t *be_abi_introduce(be_irg_t *birg)
pmap_entry *ent;
ir_node *dummy;
optimization_state_t state;
+ unsigned *limited_bitset;
be_omit_fp = birg->main_env->options->omit_fp;
obstack_init(&env->obst);
- env->isa = birg->main_env->arch_env->isa;
- env->method_type = get_entity_type(get_irg_entity(irg));
- env->call = be_abi_call_new();
+ env->isa = birg->main_env->arch_env->isa;
+ 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->ignore_regs = pset_new_ptr_default();
- env->keep_map = pmap_create();
- env->dce_survivor = new_survive_dce();
- env->birg = birg;
- env->stack_phis = pset_new_ptr(16);
+ env->ignore_regs = pset_new_ptr_default();
+ env->keep_map = pmap_create();
+ env->dce_survivor = new_survive_dce();
+ env->birg = birg;
+
+ env->sp_req.type = arch_register_req_type_limited;
+ env->sp_req.cls = arch_register_get_class(env->isa->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));
+ 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);
+
/* 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);
restore_optimization_state(&state);
FIRM_DBG_REGISTER(env->dbg, "firm.be.abi");
- memcpy(&env->irn_handler, &abi_irn_handler, sizeof(abi_irn_handler));
- env->irn_ops.impl = &abi_irn_ops;
+ env->calls = NEW_ARR_F(ir_node*, 0);
/* Lower all call nodes in the IRG. */
process_calls(env);
/* Process the IRG */
modify_irg(env);
+ /* fix call inputs for state registers */
+ fix_call_state_inputs(env);
+
/* We don't need the keep map anymore. */
pmap_destroy(env->keep_map);
+ /* calls array is not needed anymore */
+ DEL_ARR_F(env->calls);
+
/* reroute the stack origin of the calls to the true stack origin. */
- edges_reroute(dummy, env->init_sp, irg);
- edges_reroute(old_frame, get_irg_frame(irg), irg);
+ exchange(dummy, env->init_sp);
+ exchange(old_frame, get_irg_frame(irg));
/* Make some important node pointers survive the dead node elimination. */
survive_dce_register_irn(env->dce_survivor, &env->init_sp);
- pmap_foreach(env->regs, ent)
+ pmap_foreach(env->regs, ent) {
survive_dce_register_irn(env->dce_survivor, (ir_node **) &ent->value);
-
- arch_env_push_irn_handler(env->birg->main_env->arch_env, &env->irn_handler);
+ }
env->call->cb->done(env->cb);
env->cb = NULL;
void be_abi_free(be_abi_irg_t *env)
{
+ be_abi_call_free(env->call);
free_survive_dce(env->dce_survivor);
- del_pset(env->stack_phis);
del_pset(env->ignore_regs);
pmap_destroy(env->regs);
obstack_free(&env->obst, NULL);
- arch_env_pop_irn_handler(env->birg->main_env->arch_env);
free(env);
}
*/
-struct fix_stack_walker_info {
- nodeset *nodes;
- const arch_env_t *aenv;
-};
+typedef ir_node **node_array;
+
+typedef struct fix_stack_walker_env_t {
+ node_array sp_nodes;
+ const arch_env_t *arch_env;
+} fix_stack_walker_env_t;
/**
* Walker. Collect all stack modifying nodes.
*/
-static void collect_stack_nodes_walker(ir_node *irn, void *data)
+static void collect_stack_nodes_walker(ir_node *node, void *data)
{
- struct fix_stack_walker_info *info = data;
+ fix_stack_walker_env_t *env = data;
- if (is_Block(irn))
- return;
-
- if (arch_irn_is(info->aenv, irn, modify_sp)) {
- assert(get_irn_mode(irn) != mode_M && get_irn_mode(irn) != mode_T);
- pset_insert_ptr(info->nodes, irn);
+ if (arch_irn_is(env->arch_env, node, modify_sp)) {
+ assert(get_irn_mode(node) != mode_M && get_irn_mode(node) != mode_T);
+ ARR_APP1(ir_node*, env->sp_nodes, node);
}
}
-void be_abi_fix_stack_nodes(be_abi_irg_t *env, be_lv_t *lv)
+void be_abi_fix_stack_nodes(be_abi_irg_t *env)
{
- pset *stack_nodes = pset_new_ptr(16);
- struct fix_stack_walker_info info;
+ be_ssa_construction_env_t senv;
+ int i, len;
+ ir_node **phis;
+ 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);
+
+ /* nothing to be done if we didn't find any node, in fact we mustn't
+ * continue, as for endless loops incsp might have had no users and is bad
+ * now.
+ */
+ len = ARR_LEN(walker_env.sp_nodes);
+ if(len == 0) {
+ DEL_ARR_F(walker_env.sp_nodes);
+ return;
+ }
- info.nodes = stack_nodes;
- info.aenv = env->birg->main_env->arch_env;
+ be_ssa_construction_init(&senv, birg);
+ be_ssa_construction_add_copies(&senv, walker_env.sp_nodes,
+ ARR_LEN(walker_env.sp_nodes));
+ be_ssa_construction_fix_users_array(&senv, walker_env.sp_nodes,
+ ARR_LEN(walker_env.sp_nodes));
- be_assure_dom_front(env->birg);
+ if(lv != NULL) {
+ len = ARR_LEN(walker_env.sp_nodes);
+ for(i = 0; i < len; ++i) {
+ be_liveness_update(lv, walker_env.sp_nodes[i]);
+ }
+ be_ssa_construction_update_liveness_phis(&senv, lv);
+ }
+
+ phis = be_ssa_construction_get_new_phis(&senv);
+
+ /* set register requirements for stack phis */
+ len = ARR_LEN(phis);
+ for(i = 0; i < len; ++i) {
+ 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);
+ }
+ be_ssa_construction_destroy(&senv);
- 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(env->birg->dom_front, lv, stack_nodes, env->stack_phis);
- del_pset(stack_nodes);
+ DEL_ARR_F(walker_env.sp_nodes);
}
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 abi->start_barrier;
}
-/*
- _____ _____ _ _ _ _ _ _
- |_ _| __ \| \ | | | | | | | | |
- | | | |__) | \| | | |__| | __ _ _ __ __| | | ___ _ __
- | | | _ /| . ` | | __ |/ _` | '_ \ / _` | |/ _ \ '__|
- _| |_| | \ \| |\ | | | | | (_| | | | | (_| | | __/ |
- |_____|_| \_\_| \_| |_| |_|\__,_|_| |_|\__,_|_|\___|_|
-
- for Phi nodes which are created due to stack modifying nodes
- such as IncSP, AddSP and SetSP.
-
- These Phis are always to be ignored by the reg alloc and are
- fixed on the SP register of the ISA.
-*/
-
-static const void *abi_get_irn_ops(const arch_irn_handler_t *handler, const ir_node *irn)
-{
- const be_abi_irg_t *abi = get_abi_from_handler(handler);
- const void *res = NULL;
-
- if(is_Phi(irn) && pset_find_ptr(abi->stack_phis, (void *) irn))
- res = &abi->irn_ops;
-
- return res;
-}
-
-static void be_abi_limited(void *data, bitset_t *bs)
-{
- be_abi_irg_t *abi = data;
- bitset_clear_all(bs);
- bitset_set(bs, abi->isa->sp->index);
-}
-
-static const arch_register_req_t *abi_get_irn_reg_req(const void *self, arch_register_req_t *req, const ir_node *irn, int pos)
-{
- be_abi_irg_t *abi = get_abi_from_ops(self);
- const arch_register_t *reg = abi->isa->sp;
-
- memset(req, 0, sizeof(req[0]));
-
- if(pos == BE_OUT_POS(0)) {
- req->cls = reg->reg_class;
- req->type = arch_register_req_type_limited;
- req->limited = be_abi_limited;
- req->limited_env = abi;
- }
-
- else if(pos >= 0 && pos < get_irn_arity(irn)) {
- req->cls = reg->reg_class;
- req->type = arch_register_req_type_normal;
- }
-
- return req;
-}
-
-static void abi_set_irn_reg(const void *self, ir_node *irn, const arch_register_t *reg)
-{
-}
-
-static const arch_register_t *abi_get_irn_reg(const void *self, const ir_node *irn)
-{
- const be_abi_irg_t *abi = get_abi_from_ops(self);
- return abi->isa->sp;
-}
-
-static arch_irn_class_t abi_classify(const void *_self, const ir_node *irn)
-{
- return arch_irn_class_normal;
-}
-
-static arch_irn_flags_t abi_get_flags(const void *_self, const ir_node *irn)
-{
- return arch_irn_flags_ignore | arch_irn_flags_modify_sp;
-}
-
-static 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_offset(const void *_self, ir_node *irn, int bias)
-{
-}
-
-static int abi_get_sp_bias(const void *self, const ir_node *irn)
-{
- return 0;
-}
-
-static const arch_irn_ops_if_t abi_irn_ops = {
- abi_get_irn_reg_req,
- abi_set_irn_reg,
- abi_get_irn_reg,
- abi_classify,
- abi_get_flags,
- abi_get_frame_entity,
- abi_set_frame_entity,
- abi_set_frame_offset,
- abi_get_sp_bias,
- NULL, /* get_inverse */
- NULL, /* get_op_estimated_cost */
- NULL, /* possible_memory_operand */
- NULL, /* perform_memory_operand */
-};
-
-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.