ir_node *be_duplicate_node(ir_node *node)
{
ir_node *block = be_transform_node(get_nodes_block(node));
ir_graph *irg = env.irg;
dbg_info *dbgi = get_irn_dbg_info(node);
ir_mode *mode = get_irn_mode(node);
ir_op *op = get_irn_op(node);
ir_node *new_node;
int arity = get_irn_arity(node);
if (op->opar == oparity_dynamic) {
new_node = new_ir_node(dbgi, irg, block, op, mode, -1, NULL);
for (int i = 0; i < arity; ++i) {
ir_node *in = get_irn_n(node, i);
in = be_transform_node(in);
add_irn_n(new_node, in);
}
} else {
ir_node **ins = ALLOCAN(ir_node*, arity);
for (int i = 0; i < arity; ++i) {
ir_node *in = get_irn_n(node, i);
ins[i] = be_transform_node(in);
}
new_node = new_ir_node(dbgi, irg, block, op, mode, arity, ins);
}
copy_node_attr(irg, node, new_node);
be_duplicate_deps(node, new_node);
new_node->node_nr = node->node_nr;
return new_node;
}
unsigned get_ia32_latency(const ir_node *node)
{
assert(is_ia32_irn(node));
const ir_op *op = get_irn_op(node);
const ia32_op_attr_t *op_attr = (ia32_op_attr_t*) get_op_attr(op);
return op_attr->latency;
}
/**
* Copies a node to a new irg. The Ins of the new node point to
* the predecessors on the old irg. n->link points to the new node.
*
* @param n The node to be copied
* @param irg the new irg
*
* Does NOT copy standard nodes like Start, End etc that are fixed
* in an irg. Instead, the corresponding nodes of the new irg are returned.
* Note further, that the new nodes have no block.
*/
static void copy_irn_to_irg(ir_node *n, ir_graph *irg)
{
/* do not copy standard nodes */
ir_node *nn = NULL;
switch (get_irn_opcode(n)) {
case iro_NoMem:
nn = get_irg_no_mem(irg);
break;
case iro_Block: {
ir_graph *old_irg = get_irn_irg(n);
if (n == get_irg_start_block(old_irg))
nn = get_irg_start_block(irg);
else if (n == get_irg_end_block(old_irg))
nn = get_irg_end_block(irg);
break;
}
case iro_Start:
nn = get_irg_start(irg);
break;
case iro_End:
nn = get_irg_end(irg);
break;
case iro_Proj: {
ir_graph *old_irg = get_irn_irg(n);
if (n == get_irg_frame(old_irg))
nn = get_irg_frame(irg);
else if (n == get_irg_initial_mem(old_irg))
nn = get_irg_initial_mem(irg);
else if (n == get_irg_args(old_irg))
nn = get_irg_args(irg);
break;
}
}
if (nn) {
set_irn_link(n, nn);
return;
}
nn = new_ir_node(get_irn_dbg_info(n),
irg,
NULL, /* no block yet, will be set later */
get_irn_op(n),
get_irn_mode(n),
get_irn_arity(n),
get_irn_in(n));
/* Copy the attributes. These might point to additional data. If this
was allocated on the old obstack the pointers now are dangling. This
frees e.g. the memory of the graph_arr allocated in new_immBlock. */
copy_node_attr(irg, n, nn);
set_irn_link(n, nn);
}
/**
* Wrapper for specific lower function.
*/
static void lower_node(ir_node *n, void *env)
{
ir_op *op = get_irn_op(n);
lower_softfloat_func lower_func = (lower_softfloat_func) op->ops.generic;
if (lower_func != NULL) {
bool *changed = (bool*)env;
*changed |= lower_func(n);
}
}
static ir_node *transform_proj(ir_node *node)
{
ir_node *pred = get_Proj_pred(node);
ir_op *pred_op = get_irn_op(pred);
be_transform_func *proj_transform
= (be_transform_func*)pred_op->ops.generic1;
/* we should have a Proj transformer registered */
assert(proj_transform != NULL);
return proj_transform(node);
}
/**
* Adapts the mode of the given node.
*/
static void lower_mode(ir_node *n, void *env)
{
(void)env;
ir_op *op = get_irn_op(n);
lower_softfloat_func lower_func = (lower_softfloat_func) op->ops.generic;
ir_mode *mode = get_irn_mode(n);
if (lower_func != NULL) {
lower_func(n);
return;
}
set_irn_mode(n, get_lowered_mode(mode));
}
/**
* Transform helper for blocks.
*/
static ir_node *transform_block(ir_node *node)
{
ir_graph *irg = get_irn_irg(node);
dbg_info *dbgi = get_irn_dbg_info(node);
ir_mode *mode = get_irn_mode(node);
ir_node *block = new_ir_node(dbgi, irg, NULL, get_irn_op(node), mode,
get_irn_arity(node), get_irn_in(node) + 1);
copy_node_attr(irg, node, block);
block->node_nr = node->node_nr;
/* transfer execfreq value */
double execfreq = get_block_execfreq(node);
set_block_execfreq(block, execfreq);
/* put the preds in the worklist */
be_enqueue_preds(node);
return block;
}
static ir_node *transform_proj(ir_node *node)
{
ir_node *pred = get_Proj_pred(node);
ir_op *pred_op = get_irn_op(pred);
be_transform_func *proj_transform
= (be_transform_func*)pred_op->ops.generic1;
/* we should have a Proj transformer registered */
#ifdef DEBUG_libfirm
if (!proj_transform) {
unsigned const node_pn = get_Proj_num(node);
if (is_Proj(pred)) {
unsigned const pred_pn = get_Proj_num(pred);
ir_node *const pred_pred = get_Proj_pred(pred);
panic("no transformer for %+F (%u) -> %+F (%u) -> %+F", node, node_pn, pred, pred_pn, pred_pred);
} else {
panic("no transformer for %+F (%u) -> %+F", node, node_pn, pred);
}
}
#endif
return proj_transform(node);
}
void be_emit_node(ir_node const *const node)
{
be_dwarf_location(get_irn_dbg_info(node));
ir_op *const op = get_irn_op(node);
emit_func *const emit = get_generic_function_ptr(emit_func, op);
DEBUG_ONLY(if (!emit) panic("no emit handler for node %+F (%+G, graph %+F)", node, node, get_irn_irg(node));)
copy_node_attr(irg, node, new_node);
be_duplicate_deps(node, new_node);
new_node->node_nr = node->node_nr;
return new_node;
}
ir_node *be_transform_node(ir_node *node)
{
ir_node *new_node = be_get_transformed_node(node);
if (new_node != NULL)
return new_node;
DEBUG_ONLY(be_set_transformed_node(node, NULL);)
ir_op *op = get_irn_op(node);
be_transform_func *transform = (be_transform_func *)op->ops.generic;
new_node = transform(node);
assert(new_node != NULL);
be_set_transformed_node(node, new_node);
return new_node;
}
void be_enqueue_preds(ir_node *node)
{
/* put the preds in the worklist */
int arity = get_irn_arity(node);
for (int i = 0; i < arity; ++i) {
ir_node *pred = get_irn_n(node, i);
