ir_node *be_transform_phi(ir_node *node, const arch_register_req_t *req)
{
ir_node *block = be_transform_node(get_nodes_block(node));
ir_graph *irg = get_Block_irg(block);
dbg_info *dbgi = get_irn_dbg_info(node);
/* phi nodes allow loops, so we use the old arguments for now
* and fix this later */
ir_node **ins = get_irn_in(node)+1;
int arity = get_irn_arity(node);
ir_mode *mode = req->cls != NULL ? req->cls->mode : get_irn_mode(node);
ir_node *phi = new_ir_node(dbgi, irg, block, op_Phi, mode, arity, ins);
copy_node_attr(irg, node, phi);
be_duplicate_deps(node, phi);
backend_info_t *info = be_get_info(phi);
struct obstack *obst = be_get_be_obst(irg);
info->in_reqs = OALLOCN(obst, const arch_register_req_t*, arity);
for (int i = 0; i < arity; ++i) {
info->in_reqs[i] = req;
}
arch_set_irn_register_req_out(phi, 0, req);
be_enqueue_preds(node);
return phi;
}
arch_register_req_t *be_create_cls_req(ir_graph *const irg, arch_register_class_t const *const cls, unsigned char const width)
{
struct obstack *const obst = be_get_be_obst(irg);
arch_register_req_t *const req = OALLOCZ(obst, arch_register_req_t);
req->cls = cls;
req->width = width;
return req;
}
static const char *ia32_get_old_node_name(const ir_node *irn)
{
ir_graph *irg = get_irn_irg(irn);
struct obstack *obst = be_get_be_obst(irg);
lc_eoprintf(firm_get_arg_env(), obst, "%+F", irn);
obstack_1grow(obst, 0);
return (const char*)obstack_finish(obst);
}
ir_node *be_new_Phi0(ir_node *const block, ir_mode *const mode, arch_register_req_t const *const req)
{
ir_graph *const irg = get_irn_irg(block);
ir_node *const phi = new_ir_node(NULL, irg, block, op_Phi, mode, 0, NULL);
struct obstack *const obst = be_get_be_obst(irg);
backend_info_t *const info = be_get_info(phi);
info->out_infos = NEW_ARR_DZ(reg_out_info_t, obst, 1);
info->out_infos[0].req = req;
return phi;
}
void be_make_start_out(be_start_info_t *const info, ir_node *const start,
unsigned const pos, arch_register_t const *const reg,
bool const ignore)
{
info->pos = pos;
info->irn = NULL;
arch_register_req_t const *const req = ignore
? be_create_reg_req(be_get_be_obst(get_irn_irg(start)), reg, true)
: reg->single_req;
arch_set_irn_register_req_out(start, pos, req);
arch_set_irn_register_out(start, pos, reg);
}
arch_register_req_t const *be_create_reg_req(ir_graph *const irg, arch_register_t const *const reg, bool const ignore)
{
if (!ignore)
return reg->single_req;
struct obstack *const obst = be_get_be_obst(irg);
arch_register_class_t const *const cls = reg->cls;
unsigned *const limited = rbitset_obstack_alloc(obst, cls->n_regs);
rbitset_set(limited, reg->index);
arch_register_req_t *const req = OALLOCZ(obst, arch_register_req_t);
req->cls = cls;
req->limited = limited;
req->width = 1;
req->ignore = ignore;
return req;
}
ir_node *be_new_Phi(ir_node *block, int n_ins, ir_node **ins, arch_register_req_t const *req)
{
ir_graph *irg = get_irn_irg(block);
ir_node *phi = new_ir_node(NULL, irg, block, op_Phi, req->cls->mode, n_ins, ins);
phi->attr.phi.u.backedge = new_backedge_arr(get_irg_obstack(irg), n_ins);
struct obstack *obst = be_get_be_obst(irg);
backend_info_t *info = be_get_info(phi);
info->out_infos = NEW_ARR_DZ(reg_out_info_t, obst, 1);
info->in_reqs = be_allocate_in_reqs(irg, n_ins);
info->out_infos[0].req = req;
for (int i = 0; i < n_ins; ++i) {
info->in_reqs[i] = req;
}
verify_new_node(phi);
return optimize_node(phi);
}
void be_info_new_node(ir_graph *irg, ir_node *node)
{
/* Projs need no be info, all info is fetched from their predecessor */
if (is_Proj(node))
return;
struct obstack *obst = be_get_be_obst(irg);
backend_info_t *info = OALLOCZ(obst, backend_info_t);
assert(node->backend_info == NULL);
node->backend_info = info;
/*
* Set backend info for some middleend nodes which still appear in
* backend graphs
*/
arch_irn_flags_t flags = arch_irn_flag_not_scheduled;
arch_register_req_t const *req = arch_no_register_req;
switch (get_irn_opcode(node)) {
case iro_Block:
case iro_Dummy:
case iro_Anchor:
case iro_Bad:
case iro_End:
case iro_Unknown:
break;
case iro_NoMem:
case iro_Pin:
case iro_Sync:
req = arch_memory_req;
break;
case iro_Phi:
flags = arch_irn_flag_schedule_first;
break;
default:
return;
}
info->flags = flags;
info->out_infos = NEW_ARR_DZ(reg_out_info_t, obst, 1);
info->out_infos[0].req = req;
}
/**
* Initializes the generic attribute of all be nodes and return it.
*/
static void init_node_attr(ir_node *const node, unsigned const n_outputs, arch_irn_flags_t const flags)
{
ir_graph *irg = get_irn_irg(node);
backend_info_t *info = be_get_info(node);
unsigned const arity = get_irn_arity(node);
arch_register_req_t const **const in_reqs =
is_irn_dynamic(node) ? NEW_ARR_F(arch_register_req_t const*, arity) :
arity != 0 ? be_allocate_in_reqs(irg, arity) :
NULL;
for (unsigned i = 0; i < arity; ++i) {
in_reqs[i] = arch_no_register_req;
}
info->in_reqs = in_reqs;
struct obstack *const obst = be_get_be_obst(irg);
info->out_infos = NEW_ARR_DZ(reg_out_info_t, obst, n_outputs);
for (unsigned i = 0; i < n_outputs; ++i) {
info->out_infos[i].req = arch_no_register_req;
}
info->flags = flags;
}
static void arm_generate_code(FILE *output, const char *cup_name)
{
be_gas_emit_types = false;
be_gas_elf_type_char = '%';
be_begin(output, cup_name);
unsigned *const sp_is_non_ssa = rbitset_alloca(N_ARM_REGISTERS);
rbitset_set(sp_is_non_ssa, REG_SP);
arm_emit_file_prologue();
foreach_irp_irg(i, irg) {
if (!be_step_first(irg))
continue;
struct obstack *obst = be_get_be_obst(irg);
be_birg_from_irg(irg)->isa_link = OALLOCZ(obst, arm_irg_data_t);
be_birg_from_irg(irg)->non_ssa_regs = sp_is_non_ssa;
arm_select_instructions(irg);
be_step_schedule(irg);
be_timer_push(T_RA_PREPARATION);
be_sched_fix_flags(irg, &arm_reg_classes[CLASS_arm_flags], NULL, NULL, NULL);
be_timer_pop(T_RA_PREPARATION);
be_step_regalloc(irg, &arm_regalloc_if);
be_timer_push(T_EMIT);
arm_finish_graph(irg);
arm_emit_function(irg);
be_timer_pop(T_EMIT);
be_step_last(irg);
}
be_finish();
}
static arch_register_req_t *allocate_reg_req(ir_graph *const irg)
{
struct obstack *obst = be_get_be_obst(irg);
arch_register_req_t *req = OALLOCZ(obst, arch_register_req_t);
return req;
}